/**
 *  @author     STF 574
 *  @version    $Id$
 *  @desc       This module provides the TP behaviour functions at GM interface
 */

module AtsImsIot_TP_behavior_GM {

    // LibIms
    import from LibIms_Templates all;
    import from LibIms_UpperTester all;
    // LibIot
    import from LibIot_TypesAndValues all;
    import from LibIot_Functions all;
    import from LibIot_TestInterface all;
    import from LibIot_PIXITS all;
    // LibSip
    import from LibSip_SIPTypesAndValues all;
    import from LibSip_Templates all;
    import from LibSip_Common all;
    import from LibSip_SDPTypes all;
    // LibMsrp
    import from LibMsrp_TypesAndValues all;
    import from LibMsrp_Functions all;
    import from LibMsrp_Templates all;
    // AtsImsIot
    import from AtsImsIot_TestSystem all;
    import from AtsImsIot_Templates all;
    import from AtsImsIot_Templates_GM all;
    import from AtsImsIot_TypesAndValues all;
    import from AtsImsIot_Functions all;
    
    group imsMessages {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a SIP messages greater than 1300 bytes
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isNotRegisteredTo the IMS_A
         * }
         * 
         * Expected behaviour
         *     ensure that {
         *         when {
         *             the UE_A entity isRequestedToSend a MESSAGE containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA,
         *                 ContentLength indicating value greater than 1300 bytes
         *                 ;
         *             to the IMS_P_CSCF_A entity
         *         }
         *         then {
         *             the IMS_P_CSCF_A entity receives the MESSAGE containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA,
         *                 ContentLength indicating value greater than 1300 bytes
         *                 ;
         *             from the UE_A entity
         *             and the IMS_P_CSCF_A entity sends a 200_Ok containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA,
         *                 PChargingVector containing
         *                     orig_ioi indicating value PX_OPERATOR_ID_A,
         *                     term_ioi indicating value PX_OPERATOR_ID_B,
         *                 not PAccessNetworkInfo
         *             ;;
         *             to the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_MESSAGE_01(
                                                    SipInterfaceMonitor p_monitorCompRef,
                                                    in boolean p_checkMessage := true
                                                    ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipRequest(mdw_MESSAGE_1500c)
                                                        }, // FIXME CallId and more can be checked
                                                        { mw_SipRequest(mw_MESSAGE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_MESSAGE_01 - Request",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipResponse(mw_200OK_Base)
                                                        }, // FIXME CallId and more can be checked
                                                        { },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_MESSAGE_01 - Response",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_MESSAGE_01
        
    } // End of group imsMessages
    
    // 5.2  IMS Registration
    group imsRegistration {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a first registration (Successful)
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isNotRegisteredTo the IMS_A and
         *     the UE_B entity isNotRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         *     ensure that {
         *         when {
         *             the UE_A entity isTriggeredToStart
         *         }
         *         then {
         *             the UE_A entity sends a REGISTER containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA,
         *                 Authorization containing
         *                     Authentication_Schema indicating value PX_TO_BE_DEFINED,
         *                     Authentication_URI indicating value PX_TO_BE_DEFINED,
         *                     Username indicating value PX_UE_A_USERNAME,
         *                     Realm indicating value PX_UE_A_REALM,
         *                     Algorithm indicating value PX_UE_A_AUTH_ALG,
         *                     Nonce indicating value "",
         *                     not term_ioi,
         *                 not SecurityClient
         *                 ;;
         *             to the IMS_P_CSCF_A entity
         *             and the UE_A entity receives an 401_Unauthorized containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA,
         *                 Path,
         *                 Warning,
         *                 PAccessNetworkInfo,
         *                 WwwAuthenticate containing
         *                     Digest,
         *                     Realm indicating value PX_UE_A_REALM,
         *                     Algorithm indicating value PX_UE_A_AUTH_ALG,
         *                     Nonce indicating value "not empty",
         *                     qop indicating value "auth"
         *                 ;;
         *             from the IMS_P_CSCF_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_REGISTER_01(
                                                     in SipInterfaceMonitor p_monitorCompRef,
                                                     in boolean p_checkMessage := false
                                                     ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
                var SipMessage v_sip;
                
                // Check the first REGISTER
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            mw_SipRequest(
                                                                          mw_TP_GM_PCSCF_REGISTER_01( // FIXME Add CallId...
                                                                                                     mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_To_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_Authorization_other
                                                                                                     )
                                                                          )
                                                        },
                                                        { 
                                                            mw_SipRequest(mw_REGISTER_Request_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_01 - First request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                // Check REGISTER 401 Unauthorized response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipResponse(mw_401Unauthorized(v_sip.request.msgHeader.cSeq, mw_WwwAuthenticate))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_401Unauthorized_Base),
                                                            mw_SipResponse(mw_Response_4xx_Base(
                                                                                                v_sip.request.msgHeader.callId,
                                                                                                v_sip.request.msgHeader.cSeq
                                                                                                )) 
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_01 - 401 Unauthorized",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_REGISTER_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a first registration (Successful)
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isNotRegisteredTo the IMS_A and
         *     the UE_B entity isNotRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         *     ensure that {
         *         when {
         *             the UE_A entity isTriggeredToStart
         *         }
         *         then {
         *             the UE_A entity sends a REGISTER containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA,
         *                 Authorization containing
         *                     Authentication_Schema indicating value PX_TO_BE_DEFINED,
         *                     Authentication_URI indicating value PX_TO_BE_DEFINED,
         *                     Username indicating value PX_UE_A_USERNAME,
         *                     Realm indicating value PX_UE_A_REALM,
         *                     Algorithm indicating value PX_UE_A_AUTH_ALG,
         *                     Nonce indicating value "",
         *                     not term_ioi,
         *                 not SecurityClient
         *                 ;;
         *             to the IMS_P_CSCF_A entity
         *             and the UE_A entity receives an 401_Unauthorized containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA,
         *                 Path,
         *                 Warning,
         *                 PAccessNetworkInfo,
         *                 WwwAuthenticate containing
         *                     Digest,
         *                     Realm indicating value PX_UE_A_REALM,
         *                     Algorithm indicating value PX_UE_A_AUTH_ALG,
         *                     Nonce indicating value "not empty",
         *                     qop indicating value "auth"
         *                 ;,
         *                 Contact indicating value "sos"
         *                 ;
         *             from the IMS_P_CSCF_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_ECO_REGISTER_01(
                                                         in SipInterfaceMonitor p_monitorCompRef,
                                                         in boolean p_checkMessage := false
                                                         ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
                var SipMessage v_sip;
                
                // Check the first REGISTER
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            mw_SipRequest(
                                                                          mw_TP_GM_PCSCF_ECO_REGISTER_01( // FIXME Add CallId...
                                                                                                         mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                         mw_To_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                         mw_Authorization_other,
                                                                                                         -, -,
                                                                                                         mw_contact(mw_ContactAddress)
                                                                                                         )
                                                                          )
                                                        },
                                                        { 
                                                            mw_SipRequest(mw_REGISTER_Request_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_01 - First request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                // Check REGISTER 401 Unauthorized response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipResponse(mw_401Unauthorized(v_sip.request.msgHeader.cSeq, mw_WwwAuthenticate))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_401Unauthorized_Base),
                                                            mw_SipResponse(mw_Response_4xx_Base(
                                                                                                v_sip.request.msgHeader.callId,
                                                                                                v_sip.request.msgHeader.cSeq
                                                                                                )) 
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_01 - 401 Unauthorized",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_ECO_REGISTER_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a first registration (Successful)
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isNotRegisteredTo the IMS_A and
         *     the UE_B entity isNotRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the IMS_P_CSCF_A entity receives a REGISTER containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Authorization containing
         *                 Authentication_Schema indicating value PX_TO_BE_DEFINED,
         *                 Authentication_URI indicating value PX_TO_BE_DEFINED,
         *                 Username indicating value PX_UE_A_USERNAME,
         *                 Realm indicating value PX_UE_A_REALM,
         *                 Algorithm indicating value PX_UE_A_AUTH_ALG,
         *                 Nonce indicating value "not empty",
         *                 qop indicating value "auth",
         *             not SecurityClient
         *             ;;
         *         from the UE_A entity
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends an 200_Ok containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             AuthenticationInfo,
         *             PAccessNetworkInfo,
         *             PAssociatedURI indicating value PX_UE_A_SIP_URI,
         *             PChargingVector,
         *                orig_ioi_parameter 
         *                    indicating value "Operator Identifier Of ImsA" ,
         *                term_ioi_parameter 
         *                    indicating value "Operator Identifier Of ImsB"
         *             Path,
         *             ServiceRoute
         *             ;
         *         to the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_REGISTER_02(
                                                     in SipInterfaceMonitor p_monitorCompRef,
                                                     in boolean p_checkMessage := false
                                                     ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
                var SipMessage v_sip;
                
                // Check the first REGISTER
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipRequest(
                                                                          mw_TP_GM_PCSCF_REGISTER_02(
                                                                                                     mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_To_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_Authorization_other
                                                                                                     )
                                                                          )
                                                        },
                                                        { 
                                                            mw_SipRequest(mw_REGISTER_Request_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_02 - Second request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                // Check REGISTER 200 OK response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipResponse(mw_200OK(
                                                                                    v_sip.request.msgHeader.cSeq,
                                                                                    v_sip.request.msgHeader.callId,
                                                                                    v_sip.request.msgHeader.fromField,
                                                                                    v_sip.request.msgHeader.toField
                                                                                    ))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_Response_2xx_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_02 - 200 OK",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_REGISTER_02
        
        /**
         * @desc Verify that the P-CSCF successfully processes an invalid first registration (Unsuccessful).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isNotRegisteredTo the IMS_A and
         *     the UE_B entity isNotRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         *     ensure that {
         *         when {
         *             the UE_A entity isTriggeredToStart
         *         }
         *         then {
         *             the IMS_P_CSCF_A entity receives a REGISTER containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA,
         *                 Authorization containing
         *                     Authentication_Schema indicating value PX_TO_BE_DEFINED,
         *                     Authentication_URI indicating value PX_TO_BE_DEFINED,
         *                     Username indicating value PX_UE_A_INVALID_USERNAME,
         *                     Realm indicating value PX_UE_A_REALM,
         *                     Algorithm indicating value PX_UE_A_AUTH_ALG,
         *                     Nonce indicating value ""
         *                 ;;
         *             from the UE_A entity
         *             and the IMS_P_CSCF_A entity sends an 404_NotFound containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID
         *                 ;
         *             to the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_REGISTER_03(
                                                     in SipInterfaceMonitor p_monitorCompRef,
                                                     in boolean p_checkMessage := false
                                                     ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A); // User removed from HSS
                var SipMessage v_sip;
                
                // Check the first REGISTER
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            mw_SipRequest(
                                                                          mw_TP_GM_PCSCF_REGISTER_03(
                                                                                                     mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_To_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_Authorization_other
                                                                                                     )
                                                                          )
                                                        },
                                                        { 
                                                            mw_SipRequest(mw_REGISTER_Request_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_03 - First request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                log("v_sip", v_sip);
                // Check REGISTER 404 Not Found response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipResponse(mw_404NotFound(v_sip.request.msgHeader.cSeq/*, mw_WwwAuthenticate*/)),
                                                            mw_SipResponse(mw_480TemporaryUnavailable(-, v_sip.request.msgHeader.cSeq/*, mw_WwwAuthenticate*/))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_Response_4xx_Base(
                                                                                                v_sip.request.msgHeader.callId,
                                                                                                v_sip.request.msgHeader.cSeq
                                                                                                )) 
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_03 - 404 Not Found",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_REGISTER_03
        
        /**
         * @desc Verify that the P-CSCF successfully processes an invalid first registration (Unsuccessful).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isNotRegisteredTo the IMS_A and
         *     the UE_B entity isNotRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         *     ensure that {
         *         when {
         *             the UE_A entity isTriggeredToStart
         *         }
         *         then {
         *             the IMS_P_CSCF_A entity receives a REGISTER containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA,
         *                 Authorization containing
         *                     Authentication_Schema indicating value PX_TO_BE_DEFINED,
         *                     Authentication_URI indicating value PX_TO_BE_DEFINED,
         *                     Username indicating value PX_UE_A_INVALID_USERNAME,
         *                     Realm indicating value PX_UE_A_REALM,
         *                     Algorithm indicating value PX_UE_A_AUTH_ALG,
         *                     Nonce indicating value ""
         *                 ;;
         *             from the UE_A entity
         *             and the IMS_P_CSCF_A entity sends an 404_NotFound containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_UE_A_SIP_URI,
         *                 CallId indicating value PX_UE_A_CALLID
         *                 ;
         *             to the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_ECO_REGISTER_03(
                                                         in SipInterfaceMonitor p_monitorCompRef,
                                                         in boolean p_checkMessage := false
                                                         ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A); // User removed from HSS
                var SipMessage v_sip;
                
                // Check the first REGISTER
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            mw_SipRequest(
                                                                          mw_TP_GM_PCSCF_ECO_REGISTER_03(
                                                                                                         mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                         mw_To_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                         mw_Authorization_other,
                                                                                                         -, -,
                                                                                                         mw_contact(mw_ContactAddress)
                                                                                                         )
                                                                          )
                                                        },
                                                        { 
                                                            mw_SipRequest(mw_REGISTER_Request_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_03 - First request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                log("v_sip", v_sip);
                // Check REGISTER 404 Not Found response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipResponse(mw_404NotFound(v_sip.request.msgHeader.cSeq/*, mw_WwwAuthenticate*/)),
                                                            mw_SipResponse(mw_480TemporaryUnavailable(-, v_sip.request.msgHeader.cSeq/*, mw_WwwAuthenticate*/))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_Response_4xx_Base(
                                                                                                v_sip.request.msgHeader.callId,
                                                                                                v_sip.request.msgHeader.cSeq
                                                                                                )) 
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_03 - 404 Not Found",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_ECO_REGISTER_03
        
        function f_mtc_check_TP_GM_PCSCF_REGISTER_04( // FIXME RMI To be reviewed
                                                     in SipInterfaceMonitor p_monitorCompRef,
                                                     in boolean p_checkMessage := false
                                                     ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
                var SipMessage v_sip;
                
                // Check the first REGISTER
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipRequest(
                                                                          mw_TP_GM_PCSCF_REGISTER_04(
                                                                                                     mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_To_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_Authorization_other
                                                                                                     )
                                                                          )
                                                        },
                                                        { 
                                                            mw_SipRequest(mw_REGISTER_Request_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_04 - First request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                
                // Check REGISTER 404 Not Found response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipResponse(mw_401Unauthorized(v_sip.request.msgHeader.cSeq, mw_WwwAuthenticate)),
                                                            mw_SipResponse(mw_480TemporaryUnavailable(-, v_sip.request.msgHeader.cSeq, mw_WwwAuthenticate))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_401Unauthorized_Base),
                                                            mw_SipResponse(mw_Response_4xx_Base(
                                                                                                v_sip.request.msgHeader.callId,
                                                                                                v_sip.request.msgHeader.cSeq
                                                                                                )) 
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_04 - 401 Unauthorized",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_REGISTER_04
        
        function f_mtc_check_TP_GM_PCSCF_REGISTER_05( // FIXME RMI To be reviewed
                                                     in SipInterfaceMonitor p_monitorCompRef,
                                                     in boolean p_checkMessage := false
                                                     ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
                var SipMessage v_sip;
                
                // Check the first REGISTER
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipRequest(
                                                                          mw_TP_GM_PCSCF_REGISTER_05(
                                                                                                     mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_To_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_Authorization_other
                                                                                                     )
                                                                          )
                                                        },
                                                        { 
                                                            mw_SipRequest(mw_REGISTER_Request_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_05 - Second request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                // Check REGISTER 200 OK response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipResponse(mw_200OK(
                                                                                    v_sip.request.msgHeader.cSeq,
                                                                                    v_sip.request.msgHeader.callId,
                                                                                    v_sip.request.msgHeader.fromField,
                                                                                    v_sip.request.msgHeader.toField
                                                                                    ))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_Response_2xx_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_05 - 200 OK",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_REGISTER_05
        
    } // End of group imsRegistration
    
    group imsDeRegistration {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a user de-registration (no SIP session active).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isRegisteredTo the IMS_A
         * }
         * 
         * Expected behaviour
         *     ensure that {
         *         when {
         *             the UE_A entity isTriggeredToDetachUser
         *         }
         *         then {
         *             the UE_A entity sends a REGISTER containing
         *                 Expire indicating value 0
         *                 ;
         *             to the IMS_P_CSCF_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_REGISTER_07(
                                                     in SipInterfaceMonitor p_monitorCompRef,
                                                     in boolean p_checkMessage := false
                                                     ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                var ImsUserInfo v_userInfoA := f_getTelUserId(PX_EUT_A);
                var SipMessage v_sip;
                
                // Check first DeREGISTER request
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipRequest(
                                                                          mw_TP_GM_PCSCF_REGISTER_07(
                                                                                                     mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_To_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                     mw_Authorization_other/*(mw_credentialIntegrityYes)*/
                                                                                                     )
                                                                          )
                                                        },
                                                        { 
                                                            mw_SipRequest(mw_REGISTER_Request_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_07 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                // Check DeREGISTER 200 OK response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipResponse(mw_200OK(
                                                                                    v_sip.request.msgHeader.cSeq,
                                                                                    v_sip.request.msgHeader.callId,
                                                                                    v_sip.request.msgHeader.fromField,
                                                                                    v_sip.request.msgHeader.toField
                                                                                    ))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_Response_2xx_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_REGISTER_07 - 200 OK",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
               p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_REGISTER_07
        
        /**
         * @desc Verify that the P-CSCF successfully processes a user de-registration (no SIP session active).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isRegisteredTo the IMS_A
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and
         *     the UE_A entity previouslyEstablishedCallWith the UE_B
         * }
         * 
         * Expected behaviour
         *     ensure that {
         *         when {
         *             the UE_A entity isTriggeredToDetachUser
         *         }
         *         then {
         *             the UE_A entity sends a REGISTER containing
         *                 Expire indicating value 0
         *                 ;
         *             to the IMS_P_CSCF_A entity and
         *             the UE_A entity receives a BYE
         *             from the IMS_P_CSCF_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_REGISTER_10(
                                                     in SipInterfaceMonitor p_monitorCompRef,
                                                     in boolean p_checkMessage := true
                                                     ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
            p_monitorCompRef.start(
                                   f_Iot_Sip_receive(
                                                    { 
                                                        mw_SipRequest(mw_REGISTER_Request_Base)
                                                        //AXR mw_SipRequest(mw_BYE_Base),
                                                    },
                                                    {},
                                                    {0, omit},
                                                    "TP_GM_PCSCF_REGISTER_10",
                                                    false,
                                                    p_checkMessage
                                                    )
                                   );
           p_monitorCompRef.done;
        }} // End of function f_mtc_check_TP_GM_PCSCF_REGISTER_10
        
    } // End of group imsDeRegistration
    
    group imsSubscribe {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a SUBSCRIBE.
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isRegisteredTo the IMS_A
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isRequestedToSend a SUBSCRIBE
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity receives an SUBSCRIBE containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE
         *             ;
         *          from the UE_A entity
         *          and the IMS_P_CSCF_A entity sends a 200_Ok containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA
         *             ;
         *          to the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_SUBSCRIBE_01(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getTelUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getTelUserId(PX_EUT_B);
                var SipMessage v_sip;
                
                // Check the SUBSCRIBE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipRequest(
                                                                          mw_TP_GM_PCSCF_SUBSCRIBE_01(
                                                                                                      -, // FIXME Set expected value
                                                                                                      mw_From_AddrUnion_TelUrl(v_userInfoA.publicId),
                                                                                                      mw_To_AddrUnion_TelUrl(v_userInfoB.publicId)
                                                                                                      ))
                                                        },
                                                        { mw_SipRequest(mw_SUBSCRIBE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_SUBSCRIBE_01 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                // Check REGISTER 200 OK response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipResponse(mw_200OK(
                                                                                    v_sip.request.msgHeader.cSeq,
                                                                                    v_sip.request.msgHeader.callId,
                                                                                    v_sip.request.msgHeader.fromField,
                                                                                    v_sip.request.msgHeader.toField
                                                                                    ))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_Response_2xx_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_MW_PCSCF_SUBSCRIBE_01 - Response",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_SUBSCRIBE_01
        
        function f_mtc_check_TP_GM_PCSCF_SUBSCRIBE_02( // FIXME RMI To be reviewed
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
//                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
//                var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B);
                var ImsUserInfo v_userInfoA := f_getTelUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getTelUserId(PX_EUT_B);
                var SipMessage v_sip;
                
                // Check the SUBSCRIBE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipRequest(
                                                                          mw_TP_GM_PCSCF_SUBSCRIBE_02(
                                                                                                      -, // FIXME Set expected value
                                                                                                      mw_From_AddrUnion_TelUrl(v_userInfoA.publicId),
                                                                                                      mw_To_AddrUnion_TelUrl(v_userInfoB.publicId)
//                                                                                                      mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
//                                                                                                      mw_To_AddrUnion_SipUrl(omit, v_userInfoB.publicId, v_userInfoB.domain)
                                                                                                      ))
                                                        },
                                                        {mw_SipRequest(mw_SUBSCRIBE_Request_Base)},
                                                        {0, omit},
                                                        "TP_GM_PCSCF_SUBSCRIBE_02 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                // Check REGISTER 200 OK response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipResponse(mw_200OK(
                                                                                    v_sip.request.msgHeader.cSeq,
                                                                                    v_sip.request.msgHeader.callId,
                                                                                    v_sip.request.msgHeader.fromField,
                                                                                    v_sip.request.msgHeader.toField
                                                                                    ))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_Response_2xx_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_MW_PCSCF_SUBSCRIBE_02 - Response",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_SUBSCRIBE_02
        
    } // End of group imsSubscribe
    
    group imsNotify {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a NOTIFY in case of IMS Administrative de-registration.
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isRegisteredTo the IMS_A
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the IMS_S_CSCF_A entity isRequestedToSend a NOTIFY
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends an NOTIFY containing
         *             Event indicating value "reg,de-reg"
         *             ;
         *          to the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_NOTIFY_01(
                                                   in SipInterfaceMonitor p_monitorCompRef,
                                                   in boolean p_checkMessage := false
                                                   ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getTelUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getTelUserId(PX_EUT_B);
                var SipMessage v_sip;
                
                // Check the NOTIFY
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipRequest(mw_TP_GM_PCSCF_NOTIFY_01(
                                                                                                   -,
                                                                                                   -, // FIXME Set expected value
                                                                                                   mw_From_AddrUnion_TelUrl(v_userInfoA.publicId),
                                                                                                   mw_To_AddrUnion_TelUrl(v_userInfoB.publicId)
                                                                                                   ))
                                                        },
                                                        { mw_SipRequest(mw_NOTIFY_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_NOTIFY_01 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                // Check REGISTER 200 OK response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipResponse(mw_200OK(
                                                                                    v_sip.request.msgHeader.cSeq,
                                                                                    v_sip.request.msgHeader.callId,
                                                                                    v_sip.request.msgHeader.fromField,
                                                                                    v_sip.request.msgHeader.toField
                                                                                    ))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_Response_2xx_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_NOTIFY_01 - Response",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_NOTIFY_01
        
    } // End of group imsNotify
    
    group imsPrack {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a PRACK in case of IMS Administrative de-registration.
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity isRegisteredTo the IMS_A
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the IMS_S_CSCF_A entity isRequestedToSend a PRACK
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends an PRACK
         *          to the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_PRACK_01(
                                                   in SipInterfaceMonitor p_monitorCompRef,
                                                   in boolean p_checkMessage := false,
                                                   in SipMessage p_sip
                                                   ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
                
                var SipMessage v_sip;
                
                // Check the PRACK
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipRequest(mw_TP_GM_PCSCF_PRACK_01(
                                                                                                   -,
                                                                                                   -, // FIXME Set expected value
                                                                                                   p_sip.request.msgHeader.fromField,
                                                                                                   p_sip.request.msgHeader.toField
                                                                                                   ))
                                                        },
                                                        { mw_SipRequest(mw_PRACK_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_PRACK_01 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, v_sip);
                if (not(isbound(v_sip))) {
                    return;
                }
                // Check REGISTER 200 OK response
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipResponse(mw_200OK(
                                                                                    v_sip.request.msgHeader.cSeq,
                                                                                    v_sip.request.msgHeader.callId,
                                                                                    v_sip.request.msgHeader.fromField,
                                                                                    v_sip.request.msgHeader.toField
                                                                                    ))
                                                        },
                                                        {
                                                            mw_SipResponse(mw_Response_2xx_Base)
                                                        },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_PRACK_01 - Response",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_PRACK_01
        
    } // End of group imsPrack
    
    group imsInvite {
        
        /**
         * @desc Verify that the P-CSCF successfully processes an initial INVITE (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isRequestedToSend an INVITE
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity receives an INVITE containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE,
         *             PAccessNetworkInfo,
         *             MessageBody containing
         *                 SDP containing
         *                     Version indicating value "0" 
         *                         ;
         *             ;;
         *         from the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_INVITE_01(
                                                   in SipInterfaceMonitor p_monitorCompRef,
                                                   in boolean p_checkMessage := false,
                                                   out SipMessage p_sip
                                                   ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getTelUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getTelUserId(PX_EUT_B);
                
                // Check the INVITE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { mw_SipRequest(mw_TP_GM_PCSCF_INVITE_01(
                                                                                                 -, // FIXME Set expected value
                                                                                                 mw_From_AddrUnion_TelUrl(-), // v_userInfoA.publicId
                                                                                                 mw_To_AddrUnion_TelUrl(-) // v_userInfoB.publicId
                                                                                                 ))
                                                        },
                                                        { mw_SipRequest(mw_INVITE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_INVITE_01 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
                log("##### GM p_sip: ", p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_INVITE_01
        
        /**
         * @desc "Verify that the P-CSCF successfully receives an initial emergency INVITE from an unregistered UE."
         * Reference 
         *     "ETSI TS 124 229 [1], Clauses 5.1.6.8.2"
         * Config Id CF_VxLTE_INT
         * PICS Selection NONE
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_A entity not isRegisteredTo the IMS_A and
         *     the UE_A entity not isEmergencyRegisteredTo the IMS_A
         *  }
         * Expected behaviour
         *     ensure that {
         *         when {
         *             the UE_A entity isRequestedToEstablishEmergencyCall
         *         }
         *         then {
         *             the IMS_P_CSCF_A entity receives an INVITE containing
         *                 From indicating value "Anonymous",
         *                 To indicating value PX_SIP_EMERGENCY_SERVICE_URN,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA, // see 5.1.6.8.2 7)
         *                 Route indicating value PX_UE_A_SERVICE_ROUTE,
         *                 MessageBody;
         *             from the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_ECO_INVITE_01(
                                                       in SipInterfaceMonitor p_monitorCompRef,
                                                       in boolean p_checkMessage := false,
                                                       out SipMessage p_sip
                                                       ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getTelUserId(PX_EUT_A_EMERGENCY);
                var ImsUserInfo v_userInfoB := f_getTelUserId(PX_PSAP);
                
                // Check the INVITE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { mw_SipRequest(mw_TP_GM_PCSCF_INVITE_01(
                                                                                                 -, // FIXME Set expected value
                                                                                                 mw_From_AddrUnion_TelUrl(-), // v_userInfoA.publicId
                                                                                                 mw_To_AddrUnion_TelUrl(-) // v_userInfoB.publicId
                                                                                                 ))
                                                        },
                                                        { mw_SipRequest(mw_INVITE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_INVITE_01 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
                log("##### GM p_sip: ", p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_ECO_INVITE_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes an initial INVITE (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isRequestedToSend an INVITE
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity sends an INVITE containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE,
         *             PAccessNetworkInfo,
         *             MessageBody containing
         *                 SDP containing
         *                     Version indicating value "0" 
         *                         ;
         *             ;;
         *         to the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_INVITE_02(
                                                   in SipInterfaceMonitor p_monitorCompRef,
                                                   in boolean p_checkMessage := false,
                                                   out SipMessage p_sip
                                                   ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B);
                
                // Check the INVITE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { mw_SipRequest(mw_TP_GM_PCSCF_INVITE_02(
                                                                                                 -, // FIXME Set expected value
                                                                                                 (
                                                                                                   mw_From_NameAddr_SipUrl({quotedString:=v_userInfoB.publicId}, v_userInfoB.publicId, v_userInfoB.domain),
                                                                                                   mw_From_AddrUnion_TelUrl(v_userInfoB.publicId)
                                                                                                 ),
                                                                                                 (
                                                                                                   mw_To_NameAddr_SipUrl({quotedString:=v_userInfoA.publicId}, v_userInfoA.publicId/*, v_userInfoA.domain*/),
                                                                                                   mw_To_AddrUnion_TelUrl(-)//v_userInfoA.publicId
                                                                                                 )
                                                                                                 ))
                                                        },
                                                        { mw_SipRequest(mw_INVITE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_INVITE_02 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_INVITE_02
        
        /**
         * @desc "Verify that the P-CSCF successfully receives an initial emergency INVITE from an emergency registered UE."
         * Reference 
         *     "ETSI TS 124 229 [1], Clauses 5.1.6.8.3"
         * Config Id CF_VxLTE_INT
         * PICS Selection NONE
         * Initial conditions with {
         *     the UE_A entity isEmergencyAttachedTo the EPC_A and
         *     the UE_A entity isEmergencyRegisteredTo the IMS_A
         *  }
         * Expected behaviour
         *     ensure that {
         *         when {
         *             the UE_A entity isRequestedToEstablishEmergencyCall
         *         }
         *         then {
         *             the IMS_P_CSCF_A entity receives an INVITE containing
         *                 From indicating value PX_UE_A_SIP_URI,
         *                 To indicating value PX_SIP_EMERGENCY_SERVICE_URN,
         *                 CallId indicating value PX_UE_A_CALLID,
         *                 Via indicating value PX_UE_A_VIA,
         *                 Route indicating value PX_UE_A_SERVICE_ROUTE,
         *                 PPreferredIdentity, // one or two instances
         *                 // TODO Geolocation header maybe added later, check!
         *                 MessageBody;
         *             from the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_ECO_INVITE_02(
                                                       in SipInterfaceMonitor p_monitorCompRef,
                                                       in boolean p_checkMessage := false,
                                                       out SipMessage p_sip
                                                       ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A_EMERGENCY);
                var ImsUserInfo v_userInfoB := f_getSipUserId(PX_PSAP);
                
                // Check the INVITE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { mw_SipRequest(mw_TP_GM_PCSCF_ECO_INVITE_02(
                                                                                                     -, // FIXME Set expected value
                                                                                                     (
                                                                                                       mw_From_NameAddr_SipUrl({quotedString:=v_userInfoB.publicId}, v_userInfoB.publicId, v_userInfoB.domain),
                                                                                                       mw_From_AddrUnion_TelUrl(v_userInfoB.publicId)
                                                                                                     ),
                                                                                                     (
                                                                                                       mw_To_NameAddr_SipUrl({quotedString:=v_userInfoA.publicId}, v_userInfoA.publicId/*, v_userInfoA.domain*/),
                                                                                                       mw_To_AddrUnion_TelUrl(-)//v_userInfoA.publicId
                                                                                                     )
                                                                                                     ))
                                                        },
                                                        { mw_SipRequest(mw_INVITE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_INVITE_02 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_ECO_INVITE_02
        
        function f_mtc_check_TP_GM_PCSCF_INVITE_03( // FIXME RMI To be reviewed
                                                   in SipInterfaceMonitor p_monitorCompRef,
                                                   in boolean p_checkMessage := false,
                                                   out SipMessage p_sip
                                                   ) runs on ImsTestCoordinator {
             if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B);
                
                // Check the INVITE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        {
                                                            mw_SipRequest(mw_TP_GM_PCSCF_INVITE_03(
                                                                                                   -, // FIXME Set expected value
                                                                                                   mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                   mw_To_AddrUnion_SipUrl(omit, v_userInfoB.publicId, v_userInfoB.domain)
                                                                                                   ))
                                                        },
                                                        { mw_SipRequest(mw_INVITE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_INVITE_03 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_INVITE_03
        
        function f_mtc_check_TP_GM_PCSCF_INVITE_04( // FIXME RMI To be reviewed
                                                   in SipInterfaceMonitor p_monitorCompRef,
                                                   in boolean p_checkMessage := false,
                                                   out SipMessage p_sip
                                                   ) runs on ImsTestCoordinator {
             if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B);
                
                // Check the INVITE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipRequest(mw_TP_GM_PCSCF_INVITE_04(
                                                                                                   -, // FIXME Set expected value
                                                                                                   mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                   mw_To_AddrUnion_SipUrl(omit, v_userInfoB.publicId, v_userInfoB.domain)
                                                                                                   ))
                                                        },
                                                        { mw_SipRequest(mw_INVITE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_INVITE_04 - Request",
                                                        true,
                                                        p_checkMessage
                                                        )
                                       );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
             }
        } // End of function f_mtc_check_TP_GM_PCSCF_INVITE_04
        
        /**
         * @desc Verify that the P-CSCF successfully processes an initial RE-INVITE (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and
         *     the UE_A entity previouslyEstablishedCallWith the UE_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the IMS_P_CSCF_A entity receives a ReINVITE containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE,
         *             PAccessNetworkInfo,
         *             MessageBody containing
         *                 SDP containing
         *                     Version indicating value "0" 
         *                         ;
         *             ;;
         *         from the UE_A entity
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends a ReINVITE containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE,
         *             PAccessNetworkInfo,
         *             MessageBody containing
         *                 SDP containing
         *                     Version indicating value "0" 
         *                         ;
         *             ;;
         *         to the IMS_S_CSCF_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_RE_INVITE_01( // FIXME RMI To be reviewed
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false
                                                      ) runs on ImsTestCoordinator {
             if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getTelUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getTelUserId(PX_EUT_B);
                
                // Check the RE-INVITE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipRequest(mw_TP_GM_PCSCF_RE_INVITE_01(
                                                                                                      -, // FIXME Set expected value
                                                                                                      mw_From_AddrUnion_TelUrl(v_userInfoA.publicId),
                                                                                                      mw_To_AddrUnion_TelUrl(v_userInfoB.publicId)
                                                                                                      ))
                                                        },
                                                        { mw_SipRequest(mw_INVITE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_RE_INVITE_01 - Request",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
               p_monitorCompRef.done;
             }
        } // End of function TP_GM_PCSCF_RE_INVITE_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes an initial RE-INVITE (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and
         *     the UE_B entity previouslyEstablishedCallWith the UE_A
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the IMS_P_CSCF_B entity receives an ReINVITE containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE,
         *             PAccessNetworkInfo,
         *             MessageBody containing
         *                 SDP containing
         *                     Version indicating value "0" 
         *                         ;
         *             ;;
         *         from the IMS_S_CSCF_B entity
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity sends an ReINVITE containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE,
         *             PAccessNetworkInfo,
         *             MessageBody containing
         *                 SDP containing
         *                     Version indicating value "0" 
         *                         ;
         *             ;;
         *         to the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_RE_INVITE_02( // FIXME RMI To be reviewed
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false
                                                      ) runs on ImsTestCoordinator {
             if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getTelUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getTelUserId(PX_EUT_B);
                
                // Check the RE-INVITE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipRequest(mw_TP_GM_PCSCF_RE_INVITE_02(
                                                                                                      -, // FIXME Set expected value
                                                                                                      mw_From_AddrUnion_TelUrl(v_userInfoB.publicId),
                                                                                                      mw_To_AddrUnion_TelUrl(v_userInfoA.publicId)
                                                                                                      ))
                                                        },
                                                        { mw_SipRequest(mw_INVITE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_RE_INVITE_02 - Request",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
               p_monitorCompRef.done;
             }
        } // End of function TP_GM_PCSCF_RE_INVITE_02
        
        function f_mtc_check_TP_GM_PCSCF_RE_INVITE_03( // FIXME RMI To be reviewed
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false
                                                      ) runs on ImsTestCoordinator {
             if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B);
                
                // Check the RE-INVITE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipRequest(mw_TP_GM_PCSCF_RE_INVITE_03(
                                                                                                      -, // FIXME Set expected value
                                                                                                      mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                      mw_To_AddrUnion_SipUrl(omit, v_userInfoB.publicId, v_userInfoB.domain)
                                                                                                      ))
                                                        },
                                                        { mw_SipRequest(mw_INVITE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_RE_INVITE_03 - Request",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
               p_monitorCompRef.done;
             }
        } // End of function TP_GM_PCSCF_RE_INVITE_03
        
        function f_mtc_check_TP_GM_PCSCF_RE_INVITE_04( // FIXME RMI To be reviewed
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false
                                                      ) runs on ImsTestCoordinator {
             if (isvalue(p_monitorCompRef)){
                var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A);
                var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B);
                
                // Check the RE-INVITE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                        { 
                                                            mw_SipRequest(mw_TP_GM_PCSCF_RE_INVITE_04(
                                                                                                      -, // FIXME Set expected value
                                                                                                      mw_From_AddrUnion_SipUrl(omit, v_userInfoA.publicId, v_userInfoA.domain),
                                                                                                      mw_To_AddrUnion_SipUrl(omit, v_userInfoB.publicId, v_userInfoB.domain)
                                                                                                      ))
                                                        },
                                                        { mw_SipRequest(mw_INVITE_Request_Base) },
                                                        {0, omit},
                                                        "TP_GM_PCSCF_RE_INVITE_04 - Request",
                                                        false,
                                                        p_checkMessage
                                                        )
                                       );
               p_monitorCompRef.done;
             }
        } // End of function TP_GM_PCSCF_RE_INVITE_04
        
        
    } // End of group imsInvite
    
    group ims100Trying {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 100 (Trying) provisional response on initial INVITE (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the IMS_P_CSCF_A entity receives a 100_Trying
         *         from the UE_A entity
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity forwards the 100_Trying
         *         to the IMS_S_CSCF_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_100Trying_01(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      in SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 100 TRYING
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_100Trying_01(
                                                                                                      p_sip.request.msgHeader.cSeq,
                                                                                                      p_sip.request.msgHeader.fromField,
                                                                                                      p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_100Trying_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_100Trying_01",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_100Trying_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 100 (Trying) provisional response on initial INVITE (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_B entity sends a 100_Trying containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE
         *         ;
         *         to the IMS_P_CSCF_B entity
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity receives a 100_Trying containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE
         *         ;
         *         from the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_100Trying_02(
                                                      SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      in SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 100 TRYING
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_100Trying_02(
                                                                                                      p_sip.request.msgHeader.cSeq,
                                                                                                      p_sip.request.msgHeader.fromField,
                                                                                                      p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_100Trying_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_100Trying_02",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_100Trying_02
        
        function f_mtc_check_TP_GM_PCSCF_100Trying_03( // FIXME RMI To be reviewed
                                                      SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      in SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 100 TRYING
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_100Trying_03(
                                                                                                      p_sip.request.msgHeader.cSeq,
                                                                                                      p_sip.request.msgHeader.fromField,
                                                                                                      p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_100Trying_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_100Trying_03",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_100Trying_03
        
        function f_mtc_check_TP_GM_PCSCF_100Trying_04( // FIXME RMI To be reviewed
                                                      SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      in SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 100 TRYING
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_100Trying_04(
                                                                                                      p_sip.request.msgHeader.cSeq,
                                                                                                      p_sip.request.msgHeader.fromField,
                                                                                                      p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_100Trying_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_100Trying_04",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_100Trying_04
        
    } // End of group ims100Trying
    
    group ims180Ringing {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 180 (Ringing) provisional response on initial INVITE (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity hasAchieveInitialINVITE
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity receives a 180_Ringing containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         from the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_180RINGING_01(
                                                       in SipInterfaceMonitor p_monitorCompRef,
                                                       in boolean p_checkMessage := false,
                                                       in SipMessage p_sip
                                                       ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 180 RINGING
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_180Ringing_01(
                                                                                                       p_sip.request.msgHeader.cSeq,
                                                                                                       p_sip.request.msgHeader.fromField,
                                                                                                       p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_180Ringing_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_180RINGING_01",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_180RINGING_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 180 (Ringing) provisional response on initial INVITE (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_B entity sends a 180_Ringing containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         to the IMS_P_CSCF_B entity
         *         
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity receives a 180_Ringing containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         from the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_180RINGING_02(
                                                       in SipInterfaceMonitor p_monitorCompRef,
                                                       in boolean p_checkMessage := false,
                                                       in SipMessage p_sip
                                                       ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 180 RINGING
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_180Ringing_02(
                                                                                                       p_sip.request.msgHeader.cSeq,
                                                                                                       p_sip.request.msgHeader.fromField,
                                                                                                       p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_180Ringing_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_180RINGING_02",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_180RINGING_02
        
        function f_mtc_check_TP_GM_PCSCF_180RINGING_03(
                                                       in SipInterfaceMonitor p_monitorCompRef,
                                                       in boolean p_checkMessage := false,
                                                       in SipMessage p_sip
                                                       ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 180 RINGING
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_180Ringing_03(
                                                                                                       p_sip.request.msgHeader.cSeq,
                                                                                                       p_sip.request.msgHeader.fromField,
                                                                                                       p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_180Ringing_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_180RINGING_03",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_180RINGING_03
        
        function f_mtc_check_TP_GM_PCSCF_180RINGING_04(
                                                       in SipInterfaceMonitor p_monitorCompRef,
                                                       in boolean p_checkMessage := false,
                                                       in SipMessage p_sip
                                                       ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 180 RINGING
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_180Ringing_04(
                                                                                                       p_sip.request.msgHeader.cSeq,
                                                                                                       p_sip.request.msgHeader.fromField,
                                                                                                       p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_180Ringing_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_180RINGING_04",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_180RINGING_04
        
    } // End of group ims180Ringing
    
    group ims183SessionProgress {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 183 (SessionProgress) provisional response on initial INVITE (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity hasAchieveInitialINVITE
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity receives a 183_SessionProgress containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         from the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_183SESSION_PROGRESS_01(
                                                                in SipInterfaceMonitor p_monitorCompRef,
                                                                in boolean p_checkMessage := false,
                                                                in SipMessage p_sip
                                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 183 SESSION_PROGRESS
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_183SessionProgress_01(
                                                                                                               p_sip.request.msgHeader.cSeq,
                                                                                                               p_sip.request.msgHeader.fromField,
                                                                                                               p_sip.request.msgHeader.toField
                                                                                                               )) 
                                                         },
                                                         { mw_SipResponse(mw_183SessionProgress_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_183SESSION_PROGRESS_01",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_183SESSION_PROGRESS_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 183 (SessionProgress) provisional response on initial INVITE (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_B entity sends a 183_SessionProgress containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         to the IMS_P_CSCF_B entity
         *         
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity receives a 183_SessionProgress containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         from the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_183SESSION_PROGRESS_02(
                                                       in SipInterfaceMonitor p_monitorCompRef,
                                                       in boolean p_checkMessage := false,
                                                       in SipMessage p_sip
                                                       ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 183 SESSION_PROGRESS
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_183SessionProgress_02(
                                                                                                       p_sip.request.msgHeader.cSeq,
                                                                                                       p_sip.request.msgHeader.fromField,
                                                                                                       p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_183SessionProgress_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_183SESSION_PROGRESS_02",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_183SESSION_PROGRESS_02
        
        function f_mtc_check_TP_GM_PCSCF_183SESSION_PROGRESS_03(
                                                                in SipInterfaceMonitor p_monitorCompRef,
                                                                in boolean p_checkMessage := false,
                                                                in SipMessage p_sip
                                                                 ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 183 SESSION_PROGRESS
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_183SessionProgress_03(
                                                                                                       p_sip.request.msgHeader.cSeq,
                                                                                                       p_sip.request.msgHeader.fromField,
                                                                                                       p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_183SessionProgress_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_183SESSION_PROGRESS_03",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_183SESSION_PROGRESS_03
        
        function f_mtc_check_TP_GM_PCSCF_183SESSION_PROGRESS_04(
                                                       in SipInterfaceMonitor p_monitorCompRef,
                                                       in boolean p_checkMessage := false,
                                                       in SipMessage p_sip
                                                       ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 183 SESSION_PROGRESS
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_TP_GM_PCSCF_183SessionProgress_04(
                                                                                                       p_sip.request.msgHeader.cSeq,
                                                                                                       p_sip.request.msgHeader.fromField,
                                                                                                       p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_183SessionProgress_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_183SESSION_PROGRESS_04",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_183SESSION_PROGRESS_04
        
    } // End of group ims183SessionProgress
    
    group ims200Ok {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 200 (OK) provisional response on initial INVITE (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity hasAchieveInitialINVITE
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends a 200_Ok containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         to the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_200OK_01(
                                                  in SipInterfaceMonitor p_monitorCompRef,
                                                  in boolean p_checkMessage := false,
                                                  in SipMessage p_sip
                                                  ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                
                // Check the 200 OK
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   (
                                                                                      mw_To_NameAddr_TelUrl({quotedString:=f_getSipUserId(PX_EUT_B).publicId}),
                                                                                      mw_To_AddrUnion_TelUrl(f_getTelUserId(PX_EUT_B).publicId),
                                                                                      p_sip.request.msgHeader.toField
                                                                                    )
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_01",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 200 (Ok) provisional response on initial INVITE (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_B entity sends a 200_Ok containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         from the IMS_P_CSCF_B entity
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends a 200_Ok containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         from the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_200OK_02(
                                                  in SipInterfaceMonitor p_monitorCompRef,
                                                  in boolean p_checkMessage := false,
                                                  in SipMessage p_sip
                                                  ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_02",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_02
        
        function f_mtc_check_TP_GM_PCSCF_200OK_03(
                                                  in SipInterfaceMonitor p_monitorCompRef,
                                                  in boolean p_checkMessage := false,
                                                  in SipMessage p_sip
                                                  ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_03",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_03
        
        function f_mtc_check_TP_GM_PCSCF_200OK_04(
                                                  in SipInterfaceMonitor p_monitorCompRef,
                                                  in boolean p_checkMessage := false,
                                                  in SipMessage p_sip
                                                  ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_04",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_04
        
    } // End of group ims200Ok
    
    group imsAck {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a ACK provisional response on initial INVITE (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity hasAchieveInitialINVITE
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity receives an ACK containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE
         *             ;
         *         from the UE_A entity
         *         }
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_ACK_01(
                                                in SipInterfaceMonitor p_monitorCompRef,
                                                in boolean p_checkMessage := false,
                                                in SipMessage p_sip
                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the ACK
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_ACK_01(
                                                                                               p_sip.request.msgHeader.callId,
                                                                                               p_sip.request.msgHeader.cSeq,
                                                                                               -, // FIXME To be set
                                                                                               p_sip.request.msgHeader.fromField,
                                                                                               p_sip.request.msgHeader.toField
                                                                                               )) 
                                                         },
                                                         { mw_SipRequest(mw_ACK_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_ACK_01 - Request",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_ACK_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a ACK provisional response on initial INVITE (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_B entity hasAchieveInitialINVITE
         *     }
         *     then {
         *         the UE_B entity receives an ACK containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE
         *             ;
         *         from the IMS_P_CSCF_B entity
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_ACK_02(
                                                in SipInterfaceMonitor p_monitorCompRef,
                                                in boolean p_checkMessage := false,
                                                in SipMessage p_sip
                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the ACK
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_ACK_02(
                                                                                               p_sip.request.msgHeader.callId,
                                                                                               p_sip.request.msgHeader.cSeq,
                                                                                               -, // FIXME To be set
                                                                                               p_sip.request.msgHeader.fromField,
                                                                                               p_sip.request.msgHeader.toField
                                                                                               )) 
                                                         },
                                                         { mw_SipRequest(mw_ACK_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_ACK_02 - Request",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_ACK_02
        
        function f_mtc_check_TP_GM_PCSCF_ACK_03(
                                                in SipInterfaceMonitor p_monitorCompRef,
                                                in boolean p_checkMessage := false,
                                                in SipMessage p_sip
                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the ACK
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_ACK_03(
                                                                                               p_sip.request.msgHeader.callId,
                                                                                               p_sip.request.msgHeader.cSeq,
                                                                                               -, // FIXME To be set
                                                                                               p_sip.request.msgHeader.fromField,
                                                                                               p_sip.request.msgHeader.toField
                                                                                               )) 
                                                         },
                                                         { mw_SipRequest(mw_ACK_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_ACK_03 - Request",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_ACK_03
        
        function f_mtc_check_TP_GM_PCSCF_ACK_04(
                                                in SipInterfaceMonitor p_monitorCompRef,
                                                in boolean p_checkMessage := false,
                                                in SipMessage p_sip
                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the ACK
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_ACK_04(
                                                                                               p_sip.request.msgHeader.callId,
                                                                                               p_sip.request.msgHeader.cSeq,
                                                                                               -, // FIXME To be set
                                                                                               p_sip.request.msgHeader.fromField,
                                                                                               p_sip.request.msgHeader.toField
                                                                                               )) 
                                                         },
                                                         { mw_SipRequest(mw_ACK_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_ACK_04 - Request",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_ACK_04
        
    } // End of group imsAck
    
    group imsBye {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a BYE (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and
         *     the UE_A entity previouslyEstablishedCallWith the UE_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isRequestedToSend a BYE
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity receives a BYE containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE
         *             ;
         *         from the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_BYE_01(
                                                in SipInterfaceMonitor p_monitorCompRef,
                                                in boolean p_checkMessage := false,
                                                inout SipMessage p_sip
                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_BYE_01(
                                                                                               p_sip.request.msgHeader.callId,
                                                                                               -, // New CSeq
                                                                                               -, // FIXME To be set
                                                                                               p_sip.request.msgHeader.fromField,
                                                                                               p_sip.request.msgHeader.toField
                                                                                               )) 
                                                         },
                                                         { mw_SipRequest(mw_BYE_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_BYE_01 - Request",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_BYE_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a BYE (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and
         *     the UE_A entity previouslyEstablishedCallWith the UE_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_B entity isRequestedToSend a BYE
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity receives a BYE containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE
         *             ;
         *         from the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_BYE_02(
                                                in SipInterfaceMonitor p_monitorCompRef,
                                                in boolean p_checkMessage := false,
                                                inout SipMessage p_sip
                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_BYE_02(
                                                                                               p_sip.request.msgHeader.callId,
                                                                                               -, // New CSeq
                                                                                               -, // FIXME To be set
                                                                                               {
                                                                                                 fieldName := FROM_E,
                                                                                                 addressField := p_sip.request.msgHeader.toField.addressField,
                                                                                                 fromParams := *
                                                                                               }, //p_sip.request.msgHeader.fromField,
                                                                                               {
                                                                                                 fieldName := TO_E,
                                                                                                 addressField := p_sip.request.msgHeader.fromField.addressField,
                                                                                                 toParams := *
                                                                                               } //p_sip.request.msgHeader.toField
                                                                                               )) 
                                                         },
                                                         { mw_SipRequest(mw_BYE_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_BYE_02 - Request",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_BYE_02
        
        /**
         * @desc Verify that the P-CSCF successfully processes a BYE (Network initiated).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and
         *     the UE_A entity previouslyEstablishedCallWith the UE_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isNoLongerAvailable
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends a BYE containing
         *             From indicating value PX_S_CSCF_A_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE
         *             ;
         *         from the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_BYE_03(
                                                in SipInterfaceMonitor p_monitorCompRef,
                                                in boolean p_checkMessage := false,
                                                in SipMessage p_sip
                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_BYE_03(
                                                                                               p_sip.request.msgHeader.callId,
                                                                                               -, // New CSeq
                                                                                               -, // FIXME To be set
                                                                                               p_sip.request.msgHeader.fromField,
                                                                                               p_sip.request.msgHeader.toField
                                                                                               )) 
                                                         },
                                                         { mw_SipRequest(mw_BYE_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_BYE_03 - Request",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_BYE_03
        
        function f_mtc_check_TP_GM_PCSCF_BYE_04(
                                                in SipInterfaceMonitor p_monitorCompRef,
                                                in boolean p_checkMessage := false,
                                                in SipMessage p_sip
                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_BYE_04(
                                                                                               p_sip.request.msgHeader.callId,
                                                                                               -, // New CSeq
                                                                                               -, // FIXME To be set
                                                                                               p_sip.request.msgHeader.fromField,
                                                                                               p_sip.request.msgHeader.toField
                                                                                               )) 
                                                         },
                                                         { mw_SipRequest(mw_BYE_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_BYE_04 - Request",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_BYE_04
        
        function f_mtc_check_TP_GM_PCSCF_BYE_05(
                                                in SipInterfaceMonitor p_monitorCompRef,
                                                in boolean p_checkMessage := false,
                                                in SipMessage p_sip
                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_BYE_05(
                                                                                               p_sip.request.msgHeader.callId,
                                                                                               p_sip.request.msgHeader.cSeq,
                                                                                               -, // FIXME To be set
                                                                                               p_sip.request.msgHeader.fromField,
                                                                                               p_sip.request.msgHeader.toField
                                                                                               )) 
                                                         },
                                                         { mw_SipRequest(mw_ACK_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_BYE_05 - Request",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            } 
        } // End of function f_mtc_check_TP_GM_PCSCF_BYE_05
        
        function f_mtc_check_TP_GM_PCSCF_BYE_06(
                                                in SipInterfaceMonitor p_monitorCompRef,
                                                in boolean p_checkMessage := false,
                                                in SipMessage p_sip
                                                ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_BYE_06(
                                                                                               p_sip.request.msgHeader.callId,
                                                                                               p_sip.request.msgHeader.cSeq,
                                                                                               -, // FIXME To be set
                                                                                               p_sip.request.msgHeader.fromField,
                                                                                               p_sip.request.msgHeader.toField
                                                                                               )) 
                                                         },
                                                         { mw_SipRequest(mw_ACK_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_BYE_06 - Request",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_BYE_06
        
    } // End of group imsBye
    
    group ims200OkBye {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 200 (OK) BYE (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isRequestedToSend a BYE
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends a 200_Ok containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         to the IMS_S_CSCF_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_200OK_BYE_01(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      in SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_BYE_01",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_BYE_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 200 (OK) BYE (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_B entity isRequestedToSend a BYE
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity sends a 200_Ok containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         from the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_200OK_BYE_02(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      in SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_BYE_02",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_BYE_02
        
        function f_mtc_check_TP_GM_PCSCF_200OK_BYE_03(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      in SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_BYE_03",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_BYE_03
        
        function f_mtc_check_TP_GM_PCSCF_200OK_BYE_04(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      in SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_BYE_04",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_BYE_04
        
        function f_mtc_check_TP_GM_PCSCF_200OK_BYE_05(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      in SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_BYE_05",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_BYE_05
        
        function f_mtc_check_TP_GM_PCSCF_200OK_BYE_06(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      in SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK BYE
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_BYE_06",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_BYE_06
        
    } // End of group ims200OkBye
    
    group imsCancel {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a CANCEL (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and and
         *     the UE_A entity hasAchieveInitialINVITE
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isRequestedToSend a CANCEL
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity receives a CANCEL containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE
         *             ;
         *         from the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_CANCEL_01(
                                                   in SipInterfaceMonitor p_monitorCompRef,
                                                   in boolean p_checkMessage := false,
                                                   inout SipMessage p_sip
                                                   ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the CANCEL
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_CANCEL_01(
                                                                                                  p_sip.request.msgHeader.callId,
                                                                                                  p_sip.request.msgHeader.cSeq,
                                                                                                  -, // FIXME To be set
                                                                                                  p_sip.request.msgHeader.fromField,
                                                                                                  p_sip.request.msgHeader.toField
                                                                                                  )) 
                                                         },
                                                         { mw_SipRequest(mw_CANCEL_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_CANCEL_01",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_CANCEL_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a CANCEL (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and and
         *     the UE_A entity hasAchieveInitialINVITE
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isRequestedToSend a CANCEL
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity sends a CANCEL containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE
         *             ;
         *         to the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_CANCEL_02(
                                                   in SipInterfaceMonitor p_monitorCompRef,
                                                   in boolean p_checkMessage := false,
                                                   inout SipMessage p_sip
                                                   ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the CANCEL
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_CANCEL_02(
                                                                                                  p_sip.request.msgHeader.callId,
                                                                                                  p_sip.request.msgHeader.cSeq,
                                                                                                  -, // FIXME To be set
                                                                                                  p_sip.request.msgHeader.fromField,
                                                                                                  p_sip.request.msgHeader.toField
                                                                                                  )) 
                                                         },
                                                         { mw_SipRequest(mw_CANCEL_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_CANCEL_02",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_CANCEL_02
        
        function f_mtc_check_TP_GM_PCSCF_CANCEL_03(
                                                   in SipInterfaceMonitor p_monitorCompRef,
                                                   in boolean p_checkMessage := false,
                                                   inout SipMessage p_sip
                                                   ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the CANCEL
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_CANCEL_03(
                                                                                                  p_sip.request.msgHeader.callId,
                                                                                                  p_sip.request.msgHeader.cSeq,
                                                                                                  -, // FIXME To be set
                                                                                                  p_sip.request.msgHeader.fromField,
                                                                                                  p_sip.request.msgHeader.toField
                                                                                                  )) 
                                                         },
                                                         { mw_SipRequest(mw_CANCEL_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_CANCEL_03",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_CANCEL_03
        
        function f_mtc_check_TP_GM_PCSCF_CANCEL_04(
                                                   in SipInterfaceMonitor p_monitorCompRef,
                                                   in boolean p_checkMessage := false,
                                                   inout SipMessage p_sip
                                                   ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the CANCEL
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipRequest(mw_TP_GM_PCSCF_CANCEL_04(
                                                                                                  p_sip.request.msgHeader.callId,
                                                                                                  p_sip.request.msgHeader.cSeq,
                                                                                                  -, // FIXME To be set
                                                                                                  p_sip.request.msgHeader.fromField,
                                                                                                  p_sip.request.msgHeader.toField
                                                                                                  )) 
                                                         },
                                                         { mw_SipRequest(mw_CANCEL_Request_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_CANCEL_04",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_CANCEL_04
        
    } // End of group imsCancel
    
    group ims200OkCancel {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 200 (OK) CANCEL (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isRequestedToSend a CANCEL
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends a 200_Ok containing
         *             From indicating value PX_UE_A_SIP_URI,
         *             To indicating value PX_UE_B_SIP_URI,
         *             CallId indicating value PX_UE_A_CALLID,
         *             Via indicating value PX_UE_A_VIA,
         *             Route indicating value PX_UE_A_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         to the IMS_S_CSCF_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_200OK_CANCEL_01(
                                                         in SipInterfaceMonitor p_monitorCompRef,
                                                         in boolean p_checkMessage := false,
                                                         in SipMessage p_sip
                                                         ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK CANCEL
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_CANCEL_01",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_CANCEL_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 200 (OK) CANCEL (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_B entity isRequestedToSend a CANCEL
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity sends a 200_Ok containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE,
         *             not PChargingVector,
         *             not PChargingFunctionAddresses,
         *             not PPreferredIdentity
         *             ;
         *         from the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_200OK_CANCEL_02(
                                                         in SipInterfaceMonitor p_monitorCompRef,
                                                         in boolean p_checkMessage := false,
                                                         in SipMessage p_sip
                                                         ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK CANCEL
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_CANCEL_02",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_CANCEL_02
        
        function f_mtc_check_TP_GM_PCSCF_200OK_CANCEL_03(
                                                         in SipInterfaceMonitor p_monitorCompRef,
                                                         in boolean p_checkMessage := false,
                                                         in SipMessage p_sip
                                                         ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK CANCEL
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                          )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_CANCEL_03",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_CANCEL_03
        
        function f_mtc_check_TP_GM_PCSCF_200OK_CANCEL_04(
                                                         in SipInterfaceMonitor p_monitorCompRef,
                                                         in boolean p_checkMessage := false,
                                                         in SipMessage p_sip
                                                         ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 200 OK CANCEL
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { mw_SipResponse(mw_200OK(
                                                                                   p_sip.request.msgHeader.cSeq,
                                                                                   p_sip.request.msgHeader.callId,
                                                                                   p_sip.request.msgHeader.fromField,
                                                                                   p_sip.request.msgHeader.toField
                                                                                   )) 
                                                         },
                                                         { mw_SipResponse(mw_200OK_Base) },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_200OK_CANCEL_04",
                                                         false,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_200OK_CANCEL_04
        
    } // End of group ims200OkCancel
    
    group imsBusy {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 486 INVITE (busy) to reject call (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and and
         *     the UE_B entity isBusy
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_B entity isRequestedToSend a 486_INVITE
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends a 486_INVITE containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE
         *             ;
         *         to the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_486INVITE_01(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      inout SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 486 Busy
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            (
                                                             mw_SipResponse(
                                                                            mw_486Busy( // TODO Enforce template
                                                                                       p_sip.request.msgHeader.callId,
                                                                                       -, // New CSeq
                                                                                       p_sip.request.msgHeader.fromField,
                                                                                       p_sip.request.msgHeader.toField,
                                                                                       omit
                                                                                       )
                                                                            ),
                                                             mw_SipResponse(
                                                                            mw_600BusyEverywhere( // TODO Enforce template
                                                                                                 p_sip.request.msgHeader.callId,
                                                                                                 -, // New CSeq
                                                                                                 p_sip.request.msgHeader.fromField,
                                                                                                 p_sip.request.msgHeader.toField,
                                                                                                 omit
                                                                                                 )
                                                                            )
                                                             )
                                                         },
                                                         { 
                                                             mw_SipResponse(mdw_4XX_Base)
                                                         },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_486INVITE_01",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_486INVITE_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 486 INVITE (busy) to reject call (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and and
         *     the UE_B entity isBusy
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_B entity isRequestedToSend a 486_INVITE
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity receives a CANCEL containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE
         *             ;
         *         from the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_486INVITE_02(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      inout SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 486 Busy
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            (
                                                             mw_SipResponse(
                                                                            mw_486Busy( // TODO Enforce template
                                                                                       p_sip.request.msgHeader.callId,
                                                                                       -, // New CSeq
                                                                                       p_sip.request.msgHeader.fromField,
                                                                                       p_sip.request.msgHeader.toField,
                                                                                       omit
                                                                                       )
                                                                            ),
                                                             mw_SipResponse(
                                                                            mw_600BusyEverywhere( // TODO Enforce template
                                                                                                 p_sip.request.msgHeader.callId,
                                                                                                 -, // New CSeq
                                                                                                 p_sip.request.msgHeader.fromField,
                                                                                                 p_sip.request.msgHeader.toField,
                                                                                                 omit
                                                                                                 )
                                                                            )
                                                             )
                                                         },
                                                         { 
                                                             mw_SipResponse(mdw_4XX_Base)
                                                         },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_486INVITE_02",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_486INVITE_02
        
        function f_mtc_check_TP_GM_PCSCF_486INVITE_03(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      inout SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 486 Busy
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            mw_SipResponse(
                                                                          mw_486Busy( // TODO Enforce template
                                                                                     p_sip.request.msgHeader.callId,
                                                                                     -, // New CSeq
                                                                                     p_sip.request.msgHeader.fromField,
                                                                                     p_sip.request.msgHeader.toField
                                                                                     )
                                                                          )
                                                         },
                                                         { 
                                                             mw_SipResponse(mdw_4XX_Base)
                                                         },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_486INVITE_03",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_486INVITE_03
        
        function f_mtc_check_TP_GM_PCSCF_486INVITE_04(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      inout SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 486 Busy
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            mw_SipResponse(
                                                                          mw_486Busy( // TODO Enforce template
                                                                                     p_sip.request.msgHeader.callId,
                                                                                     -, // New CSeq
                                                                                     p_sip.request.msgHeader.fromField,
                                                                                     p_sip.request.msgHeader.toField
                                                                                     )
                                                                          )
                                                         },
                                                         { 
                                                             mw_SipResponse(mdw_4XX_Base)
                                                         },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_486INVITE_04",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_486INVITE_04
        
    } // End of group imsBusy
    
    group imsRequestTermination {
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 487 INVITE (Request Terminated) (Originating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and and
         *     the UE_A entity hasAchieveInitialINVITE
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isRequestedToSend a CANCEL
         *     }
         *     then {
         *         the IMS_P_CSCF_A entity sends a 487_INVITE containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE
         *             ;
         *         to the UE_A entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_487INVITE_01(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      inout SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 487 Request Terminated
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            mw_SipResponse(
                                                                          mw_487RequestTerminated( // TODO Enforce template
                                                                                                  p_sip.request.msgHeader.callId,
                                                                                                  -, // New CSeq
                                                                                                  p_sip.request.msgHeader.fromField,
                                                                                                  p_sip.request.msgHeader.toField,
                                                                                                  omit
                                                                                                  )
                                                                          )
                                                         },
                                                         { 
                                                             mw_SipResponse(mdw_4XX_Base)
                                                         },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_487INVITE_01",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_487INVITE_01
        
        /**
         * @desc Verify that the P-CSCF successfully processes a 487 INVITE (Request Terminated) (Terminating Leg).
         * Initial conditions with {
         *     the UE_A entity isAttachedTo the EPC_A and
         *     the UE_B entity isAttachedTo the EPC_B and
         *     the UE_A entity isRegisteredTo the IMS_A and
         *     the UE_B entity isRegisteredTo the IMS_B and and
         *     the UE_A entity hasAchieveInitialINVITE
         * }
         * 
         * Expected behaviour
         * ensure that {
         *     when {
         *         the UE_A entity isRequestedToSend a CANCEL
         *     }
         *     then {
         *         the IMS_P_CSCF_B entity receives a 487_INVITE containing
         *             From indicating value PX_UE_B_SIP_URI,
         *             To indicating value PX_UE_A_SIP_URI,
         *             CallId indicating value PX_UE_B_CALLID,
         *             Via indicating value PX_UE_B_VIA,
         *             Route indicating value PX_UE_B_SERVICE_ROUTE
         *             ;
         *         from the UE_B entity
         *         }
         *     }
         */
        function f_mtc_check_TP_GM_PCSCF_487INVITE_02(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      inout SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 487 Request Terminated
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            mw_SipResponse(
                                                                          mw_487RequestTerminated( // TODO Enforce template
                                                                                                  p_sip.request.msgHeader.callId,
                                                                                                  -, // New CSeq
                                                                                                  p_sip.request.msgHeader.fromField,
                                                                                                  p_sip.request.msgHeader.toField
                                                                                                  )
                                                                          )
                                                         },
                                                         { 
                                                             mw_SipResponse(mdw_4XX_Base)
                                                         },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_487INVITE_02",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_487INVITE_02
        
        function f_mtc_check_TP_GM_PCSCF_487INVITE_03(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      inout SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 487 Request Terminated
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            mw_SipResponse(
                                                                          mw_487RequestTerminated( // TODO Enforce template
                                                                                                  p_sip.request.msgHeader.callId,
                                                                                                  -, // New CSeq
                                                                                                  p_sip.request.msgHeader.fromField,
                                                                                                  p_sip.request.msgHeader.toField
                                                                                                  )
                                                                          )
                                                         },
                                                         { 
                                                             mw_SipResponse(mdw_4XX_Base)
                                                         },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_487INVITE_03",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_487INVITE_03
        
        function f_mtc_check_TP_GM_PCSCF_487INVITE_04(
                                                      in SipInterfaceMonitor p_monitorCompRef,
                                                      in boolean p_checkMessage := false,
                                                      inout SipMessage p_sip
                                                      ) runs on ImsTestCoordinator {
            if (isvalue(p_monitorCompRef)) {
                // Check the 487 Request Terminated
                p_monitorCompRef.start(
                                       f_Iot_Sip_receive(
                                                         { 
                                                            mw_SipResponse(
                                                                          mw_487RequestTerminated( // TODO Enforce template
                                                                                                  p_sip.request.msgHeader.callId,
                                                                                                  -, // New CSeq
                                                                                                  p_sip.request.msgHeader.fromField,
                                                                                                  p_sip.request.msgHeader.toField
                                                                                                  )
                                                                          )
                                                         },
                                                         { 
                                                             mw_SipResponse(mdw_4XX_Base)
                                                         },
                                                         { 0, omit },
                                                         "TP_GM_PCSCF_487INVITE_04",
                                                         true,
                                                         p_checkMessage
                                                         )
                                        );
                p_monitorCompRef.done;
                // Retrieve messge
                f_getSipMsgFromMonitor(p_monitorCompRef, p_sip);
            }
        } // End of function f_mtc_check_TP_GM_PCSCF_487INVITE_04
        
    } // End of group imsRequestTermination
    
} // End of module AtsImsIot_TP_behavior_GM