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

module AtsImsIot_TP_behavior_RX
{
    
    // LibIot
    import from LibIot_PIXITS all;
    import from LibIot_VxLTE_PIXITS all;
    import from LibIot_TestInterface all;
    import from LibIot_TypesAndValues all;
    import from LibIot_Functions all;
    
    // AtsImsIot
    import from AtsImsIot_Templates all;
    import from AtsImsIot_TypesAndValues all;
    import from AtsImsIot_Functions all;
    import from AtsImsIot_Diameter_Templates all;
    import from AtsImsIot_TestSystem all;
    
    // LibDiameter
    import from LibDiameter_Templates all;
    import from LibDiameter_TypesAndValues all;
    import from LibDiameter_Steps all;

    
group g_PCRF {

group g_PCRF_ASA {

    /**
     * Starts monitor component behavior for TP_RX_PCRF_ASA_01
     * @param p_monitorCompRef Reference to monitor component
     * <pre>
     * Test objective  "Verify that IUT sends AA-Answer after RAA is received from PGW."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isNotAttachedTo the EPC_A and
     *     the UE_A entity isNotRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when { 
     *         the IMS_P_CSCF_A entity sends a ASR containing
     *              Abort_Cause_AVP
     *                  indicating value BEARER_RELEASED '(0)'
     *              ;
     *         to the EPC_PCRF_A entity
     *     }
     *     then {
     *         the EPC_PCRF_A entity sends the ASA containing
     *             Result_Code_AVP
     *                 indicating value DIAMETER_SUCCESS "(2001)"
     *     ;
     *     to the IMS_P_CSCF_A entity
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCRF_ASA_01(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aSR_MSG := mw_ASR_abortCause(BEARER_RELEASED_E) };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aSR_MSG := mw_ASR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCRF_ASA_01 - ASR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
            
            mw_diameter_msg_pass := { aSA_MSG := mw_ASA_resultCode };
            mw_diameter_msg_fail := { aSA_MSG := mw_ASA_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCRF_ASA_01 - ASA",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCRF_ASA_01

} // end group g_PCRF_ASA

group g_PCRF_AAA {

    /**
     * Starts monitor component behavior for TP_RX_PCRF_AAA_01
     * @param p_monitorCompRef Reference to monitor component
     * <pre>
     * Test objective  "Verify that IUT after AA-Request is received due to provisioning of AF Signalling flow sends AA-Answer."
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity sends an AAR
     *         to the EPC_PCRF_A entity
     *     }
     *     then {
     *         the EPC_PCRF_A entity sends the AAA containing
     *             Result_Code_AVP
     *                 indicating value DIAMETER_SUCCESS,
     *             Acceptable_Service_Info_AVP containing
     *                 "one or more" Media_Component_Description_AVP containing
     *                     Media_Component_Number_AVP
     *                         indicating value 0,
     *                     Media_Sub_Component_AVP containing
     *                         Flow_Description_AVP
     *                         Flow_Usage_AVP
     *                             indicating value AF_SIGNALING,
     *                         Flow_Status_AVP
     *                             indicating value ENABLED,
     *                         AF_Signalling_Protocol_AVP
     *                             indicating value SIP
     *                     ;
     *                 ;
     *             ;,
     *             IP_CAN_AVP
     *             RAT_Type_AVP
     *         ;
     *         to the IMS_P_CSCF_A entity
     *         }
     *     }
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCRF_AAA_01(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAR_MSG := mw_AAR_basic };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_dummy };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCRF_AAA_01 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
            
            mw_diameter_msg_pass := { aAA_MSG := mw_AAA_resultCode/*mw_AAA_AcceptableService*/ };
            mw_diameter_msg_fail := { aAA_MSG := mw_AAA_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCRF_AAA_01 - AAA",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCRF_AAA_01

    /**
     * Starts monitor component behavior for TP_RX_PCRF_AAA_02
     * @param p_monitorCompRef Reference to monitor component
     * <pre>
     * Test objective  "Verify that IUT sends AA-Answer after RAA is received from PGW."
     * ensure that {
     *     when {
     *         the EPC_PGW_A entity sends a RAA
     *         to the EPC_PCRF_A entity
     *     }
     *     then {
     *         the EPC_PCRF_A entity sends the AAA containing
     *             Result_Code_AVP
     *                 indicating value DIAMETER_SUCCESS "(2001)"
     *             ;
     *         ;
     *         to the IMS_P_CSCF_A entity
     *     }
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCRF_AAA_02(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAA_MSG := mw_AAA_resultCode };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAA_MSG := mw_AAA_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCRF_AAA_02 - AAA",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCRF_AAA_02

    /**
     * Starts monitor component behavior for TP_RX_PCRF_AAA_02
     * @param p_monitorCompRef Reference to monitor component
     * <pre>
     * Test objective  "Verify that IUT receives AA-Request  from home PCRF and sends AA-Answer towards visited P-CSCF."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isNotAttachedTo the EPC_A and
     *     the UE_A entity isNotRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the EPC_PCRF_A entity sends a AAA
     *         to the EPC_PCRF_B entity
     *     }
     *     then {
     *         the EPC_PCRF_B entity sends the AAA 
     *         to the IMS_P_CSCF_B entity
     *     }
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCRF_AAA_03(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAA_MSG := mw_AAA_resultCode };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAA_MSG := mw_AAA_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCRF_AAA_03 - AAA",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCRF_AAA_03

} // end group g_PCRF_AAA

group g_PCRF_STA {

    /**
     * Starts monitor component behavior for TP_RX_PCRF_STA_01
     * @param p_monitorCompRef Reference to monitor component
     * <pre>
     * Test objective  "Verify that IUT after reception of RA-Request sends ST-Answer."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isNotAttachedTo the EPC_A and
     *     the UE_A entity isNotRegisteredTo the IMS_A and 
     *     the UE_A entity previouslyEstablishedCallWith the UE_B
     * }
     * 
     * ensure that {
     *     when { 
     *         the EPC_PGW_A entity sends an RAA
     *         to the EPC_PCRF_A entity
     *     }
     *     then {
     *         the EPC_PCRF_A entity sends the STA containing
     *             Result_Code_AVP
     *                 indicating value DIAMETER_SUCCESS
     *         ;
     *         to the IMS_P_CSCF_A entity
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCRF_STA_01(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { sTA_MSG := mw_STA_diamSuccess };
            var template DIAMETER_MSG mw_diameter_msg_fail := { sTA_MSG := mw_STA_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCRF_STA_01 - STA",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCRF_STA_01

    /**
     * Starts monitor component behavior for TP_RX_PCRF_STA_02
     * @param p_monitorCompRef Reference to monitor component
     * <pre>
     * Test objective  "Verify that IUT after reception of ST-Request sends ST-Answer."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isNotAttachedTo the EPC_A and
     *     the UE_A entity isNotRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when { 
     *         the IMS_P_CSCF_A entity sends an STR
     *         to the EPC_PCRF_A entity
     *     }
     *     then {
     *         the EPC_PCRF_A entity sends the STA containing
     *             Result_Code_AVP
     *                 indicating value DIAMETER_SUCCESS
     *         ;
     *         to the IMS_P_CSCF_A entity
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCRF_STA_02(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { sTR_MSG := mw_STR_basic };
            var template DIAMETER_MSG mw_diameter_msg_fail := { sTR_MSG := mw_STR_dummy };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCRF_STA_02 - STR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
            
            mw_diameter_msg_pass := { sTA_MSG := mw_STA_diamSuccess };
            mw_diameter_msg_fail := { sTA_MSG := mw_STA_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCRF_STA_02 - STA",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCRF_STA_02

} // end group g_PCRF_STA

} // end group g_PCRF


group g_PCSCF {


group g_PCSCF_ASR {

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_ASR_01
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT receives AS-Request from home PCRF and it sends AS-Request towards visited P-CSCF."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_RMI
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_B and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the EPC_PCRF_A entity sends a ASR
     *         to the EPC_PCRF_B entity
     *     }
     *     then {
     *         the EPC_PCRF_B entity sends the ASR containing
     *             Session_Id_AVP
     *             Abort_Cause_AVP
     *                 indicating value BEARER_RELEASED
     *         ;
     *         to the IMS_P_CSCF_B entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_ASR_01(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aSR_MSG := mw_ASR_abortCause(BEARER_RELEASED_E) };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aSR_MSG := mw_ASR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_ASR_01 - ASR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_ASR_01
} //end group g_PCSCF_ASR {


group g_PCSCF_AAR {

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_AAR_01
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT after 2XX_Response on REGISTER sends an AA-Request due to provisioning of AF Signalling flow."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isNotAttachedTo the EPC_A and
     *     the UE_A entity isNotRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_S_CSCF_A entity sends a 200_Response_REGISTER
     *         to the IMS_P_CSCF_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends an AAR containing
     *             Framed_IPv4_Address_AVP 
     *                 indicating value "IPv4_Address of UE_A",
     *             "or" Framed_IPv6_Address_AVP 
     *                 indicating value "IPv6_Address of UE_A",
     *             Specific_Action_AVP
     *                 indicating value INDICATION_OF_LOSS_OF_BEARER,
     *             "one or more" Media_Component_Description_AVP containing 
     *                 Media_Component_Number_AVP
     *                     indicating value 0,
     *                 Media_Sub_Component_AVP containing
     *                     Flow_Description_AVP
     *                     Flow_Usage_AVP
     *                         indicating value AF_SIGNALLING,
     *                     Flow_Status_AVP
     *                         indicating value ENABLED,
     *                     AF_Signalling_Protocol_AVP
     *                         indicating value SIP
     *                 ;
     *             ;
     *         ;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     * @remark source function f_mtc_check_TP_EPC_6013_01
     */
    function f_mtc_check_TP_RX_PCSCF_AAR_01(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAR_MSG := mw_AAR_MediaComponent_specificActionLossOfBearer };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_AAR_01 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
		}
    } // End of function f_mtc_check_TP_RX_PCSCF_AAR_01

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_AAR_02
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "IUT does not send AA-Request if 4XX_Response REGISTER is received."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isNotRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when { 
     *         the IMS_P_CSCF_A entity receives an 4XX_Response_REGISTER
     *         from the IMS_S_CSCF_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity not sends the AAR
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_AAR_02(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var boolean v_noDiameterMessageExpected := true;
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        //check if nothing received
                    },
                    {
                        mw_diameter_msg_fail //Fail criteria: check if AAR is sent
                    },
                    {0, omit},
                    "TP_RX_PCSCF_AAR_02 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage,
                    v_noDiameterMessageExpected
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_AAR_02

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_AAR_03
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT send AA-Request in case of session establishment for originating side after INVITE is received."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives an INVITE_Request_with_SDP_offer
     *         from the UE_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the AAR containing
     *             Framed_IPv4_Address_AVP 
     *                 indicating value "IPv4_Address of UE_A",
     *             "or" Framed_IPv6_Address_AVP 
     *                 indicating value "IPv6_Address of UE_A",
     *             "one or more" Media_Component_Description_AVP containing
     *                 Media_Component_Number_AVP
     *                 Media_Type_AVP
     *                 Flow_Status_AVP
     *                     indicating value DISABLED '(3)'
     *                 Max_Requested_Bandwidth_DL_AVP
     *                 RR_Bandwidth_AVP
     *                 Codec_Data_AVP
     *                 "one or more" Media_Subcomponent_Description_AVP containing
     *                     Flow_Number_AVP
     *                     Flow_Description_AVP
     *             ;
     *         ;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_AAR_03(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAR_MSG := mw_AAR_RequestType_ServiceInfoStatus_FramedIPv4(
                                                      mw_rxRequestType(INITIAL_REQUEST_E),
                                                      mw_serviceInfoStatus(PRELIMINARY_SERVICE_INFORMATION_E),
                                                      mw_framedIPAddress(f_IPV4_Address2oct(PX_SIP_GMA_UE_IPADDR))) };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_AAR_03 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_AAR_03

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_AAR_04
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT send AA-Request in case of session establishment for originating side after 180 Ringing with SDP is received."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a 180_Response_INVITE_with_SDP_offer
     *         from the IMS_S_CSCF_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the AAR containing
     *             Framed_IPv4_Address_AVP 
     *                 indicating value "IPv4_Address of UE_A",
     *             "or" Framed_IPv6_Address_AVP 
     *                 indicating value "IPv6_Address of UE_A",
     *             "one or more" Media_Component_Description_AVP containing
     *                 Media_Component_Number_AVP
     *                 Media_Type_AVP
     *                 Flow_Status_AVP
     *                     indicating value ENABLED_DOWNLINK '(1)'
     *                 Max_Requested_Bandwidth_DL_AVP
     *                 Max_Requested_Bandwidth_UL_AVP
     *                 RR_Bandwidth_AVP
     *                 RS_Bandwidth_AVP
     *                 Codec_Data_AVP
     *                 "one or more" Media_Subcomponent_Description_AVP containing
     *                     Flow_Number_AVP
     *                     Flow_Description_AVP
     *             ;
     *         ;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_AAR_04(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAR_MSG := mw_AAR_RequestType_ServiceInfoStatus_FramedIPv4(
                                                      mw_rxRequestType(UPDATE_REQUEST_E),
                                                      mw_serviceInfoStatus(FINAL_SERVICE_INFORMATION_E),
                                                      mw_framedIPAddress(f_IPV4_Address2oct(PX_SIP_GMA_UE_IPADDR))) };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_AAR_04 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_AAR_04

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_AAR_05
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT send AA-Request in case of session establishment for originating side after 200 OK with SDP is received."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a 200_Response_INVITE_with_SDP_offer
     *         from the IMS_S_CSCF_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the AAR containing
     *             Framed_IPv4_Address_AVP 
     *                 indicating value "IPv4_Address of UE_A",
     *             "or" Framed_IPv6_Address_AVP 
     *                 indicating value "IPv6_Address of UE_A",
     *             "one or more" Media_Component_Description_AVP containing
     *                 Media_Component_Number_AVP
     *                 Media_Type_AVP
     *                 Flow_Status_AVP
     *                     indicating value ENABLED '(2)'
     *                 Max_Requested_Bandwidth_DL_AVP
     *                 Max_Requested_Bandwidth_UL_AVP
     *                 RR_Bandwidth_AVP
     *                 RS_Bandwidth_AVP
     *                 Codec_Data_AVP
     *                 "one or more" Media_Subcomponent_Description_AVP containing
     *                     Flow_Number_AVP
     *                     Flow_Description_AVP
     *                 ;
     *             ;
     *         ;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_AAR_05(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAR_MSG := mw_AAR_RequestType_ServiceInfoStatus_FramedIPv4(
                                                      mw_rxRequestType(UPDATE_REQUEST_E),
                                                      mw_serviceInfoStatus(PRELIMINARY_SERVICE_INFORMATION_E),
                                                      mw_framedIPAddress(f_IPV4_Address2oct(PX_SIP_GMA_UE_IPADDR))) };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_AAR_05 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_AAR_05

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_AAR_06
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT send AA-Request in case of session establishment for terminating side after INVITE is received."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives an INVITE_Request_with_SDP_offer
     *         from the IMS_S_CSCF_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the AAR containing
     *             Framed_IPv4_Address_AVP 
     *                 indicating value "IPv4_Address of UE_A",
     *             "or" Framed_IPv6_Address_AVP 
     *                 indicating value "IPv6_Address of UE_A",
     *             "one or more" Media_Component_Description_AVP containing
     *                 Media_Component_Number_AVP
     *                 Media_Type_AVP
     *                 Flow_Status_AVP
     *                     indicating value DISABLED '(3)'
     *                 Max_Requested_Bandwidth_DL_AVP
     *                 RR_Bandwidth_AVP
     *                 Codec_Data_AVP
     *                 "one or more" Media_Subcomponent_Description_AVP containing
     *                     Flow_Number_AVP
     *                     Flow_Description_AVP
     *                 ;
     *             ;
     *         ;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_AAR_06(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAR_MSG := mw_AAR_RequestType_ServiceInfoStatus_FramedIPv4(
                                                      mw_rxRequestType(INITIAL_REQUEST_E),
                                                      mw_serviceInfoStatus(PRELIMINARY_SERVICE_INFORMATION_E),
                                                      mw_framedIPAddress(f_IPV4_Address2oct(PX_SIP_GMA_UE_IPADDR))) };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_AAR_06 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_AAR_06

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_AAR_07
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT send AA-Request in case of session establishment for terminating side after 180 Ringing with SDP is received."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a 180_Response_INVITE_with_SDP_offer
     *         from the UE_B entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the AAR containing
     *             Framed_IPv4_Address_AVP 
     *                 indicating value "IPv4_Address of UE_A",
     *             "or" Framed_IPv6_Address_AVP 
     *                 indicating value "IPv6_Address of UE_A",
     *             "one or more" Media_Component_Description_AVP containing
     *                 Media_Component_Number_AVP
     *                 Media_Type_AVP
     *                 Flow_Status_AVP
     *                     indicating value ENABLED_UPLINK '(0)'
     *                 Max_Requested_Bandwidth_DL_AVP
     *                 Max_Requested_Bandwidth_UL_AVP
     *                 RR_Bandwidth_AVP
     *                 RS_Bandwidth_AVP
     *                 Codec_Data_AVP
     *                 "one or more" Media_Subcomponent_Description_AVP containing
     *                     Flow_Number_AVP
     *                     Flow_Description_AVP
     *                 ;
     *             ;
     *         ;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_AAR_07(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAR_MSG := mw_AAR_RequestType_ServiceInfoStatus_FramedIPv4(
                                                      mw_rxRequestType(UPDATE_REQUEST_E),
                                                      mw_serviceInfoStatus(FINAL_SERVICE_INFORMATION_E),
                                                      mw_framedIPAddress(f_IPV4_Address2oct(PX_SIP_GMA_UE_IPADDR))) };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_AAR_07 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_AAR_07

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_AAR_08
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT send AA-Request in case of session establishment for terminating side after 200 OK with SDP is received."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a 200_Response_INVITE_with_SDP_offer
     *         from the UE_B entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the AAR containing
     *             Framed_IPv4_Address_AVP 
     *                 indicating value "IPv4_Address of UE_A",
     *             "or" Framed_IPv6_Address_AVP 
     *                 indicating value "IPv6_Address of UE_A",
     *             "one or more" Media_Component_Description_AVP containing
     *                 Media_Component_Number_AVP
     *                 Media_Type_AVP
     *                 Flow_Status_AVP
     *                     indicating value ENABLED '(2)'
     *                 Max_Requested_Bandwidth_DL_AVP
     *                 Max_Requested_Bandwidth_UL_AVP
     *                 RR_Bandwidth_AVP
     *                 RS_Bandwidth_AVP
     *                 Codec_Data_AVP
     *                 "one or more" Media_Subcomponent_Description_AVP containing
     *                     Flow_Number_AVP
     *                     Flow_Description_AVP
     *                 ;
     *             ;
     *         ;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_AAR_08(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAR_MSG := mw_AAR_RequestType_ServiceInfoStatus_FramedIPv4(
                                                      mw_rxRequestType(UPDATE_REQUEST_E),
                                                      mw_serviceInfoStatus(PRELIMINARY_SERVICE_INFORMATION_E),
                                                      mw_framedIPAddress(f_IPV4_Address2oct(PX_SIP_GMA_UE_IPADDR))) };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_AAR_08 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_AAR_08

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_AAR_09
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT send AA-Request in case of session modification for originating side after 200 OK on re-INVITE is received."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a 200_Response_INVITE_with_SDP_offer
     *         from the IMS_S_CSCF_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the AAR containing
     *             Framed_IPv4_Address_AVP 
     *                 indicating value "IPv4_Address of UE_A",
     *             "or" Framed_IPv6_Address_AVP 
     *                 indicating value "IPv6_Address of UE_A",
     *             "one or more" Media_Component_Description_AVP containing
     *                 Media_Component_Number_AVP
     *                 Media_Type_AVP
     *                 Flow_Status_AVP
     *                     indicating value ENABLED_UPLINK '(0)'
     *                 Max_Requested_Bandwidth_DL_AVP
     *                 Max_Requested_Bandwidth_UL_AVP
     *                 RR_Bandwidth_AVP
     *                 RS_Bandwidth_AVP
     *                 Codec_Data_AVP
     *                 "one or more" Media_Subcomponent_Description_AVP containing
     *                     Flow_Number_AVP
     *                     Flow_Description_AVP
     *                 ;
     *             ;
     *         ;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_AAR_09(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAR_MSG := mw_AAR_RequestType_ServiceInfoStatus_FramedIPv4(
                                                      mw_rxRequestType(UPDATE_REQUEST_E),
                                                      mw_serviceInfoStatus(FINAL_SERVICE_INFORMATION_E),
                                                      mw_framedIPAddress(f_IPV4_Address2oct(PX_SIP_GMA_UE_IPADDR))) };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_AAR_09 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_AAR_09

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_AAR_10
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT send AA-Request in case of session modification for terminating side after 200 OK on re-INVITE is received."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a 200_Response_INVITE_with_SDP_offer
     *         from the UE_B entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the AAR containing
     *             Framed_IPv4_Address_AVP 
     *                 indicating value "IPv4_Address of UE_A",
     *             "or" Framed_IPv6_Address_AVP 
     *                 indicating value "IPv6_Address of UE_A",
     *             "one or more" Media_Component_Description_AVP containing
     *                 Media_Component_Number_AVP
     *                 Media_Type_AVP
     *                 Flow_Status_AVP
     *                     indicating value ENABLED_DOWNLINK '(1)'
     *                 Max_Requested_Bandwidth_DL_AVP
     *                 Max_Requested_Bandwidth_UL_AVP
     *                 RR_Bandwidth_AVP
     *                 RS_Bandwidth_AVP
     *                 Codec_Data_AVP
     *                 "one or more" Media_Subcomponent_Description_AVP containing
     *                     Flow_Number_AVP
     *                     Flow_Description_AVP
     *             ;
     *         ;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_AAR_10(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { aAR_MSG := mw_AAR_RequestType_ServiceInfoStatus_FramedIPv4(
                                                      mw_rxRequestType(UPDATE_REQUEST_E),
                                                      mw_serviceInfoStatus(FINAL_SERVICE_INFORMATION_E),
                                                      mw_framedIPAddress(f_IPV4_Address2oct(PX_SIP_GMA_UE_IPADDR))) };
            var template DIAMETER_MSG mw_diameter_msg_fail := { aAR_MSG := mw_AAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_AAR_10 - AAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_AAR_10

} // end group g_PCSCF_AAR
    
group g_PCSCF_RAA {


    /**TODO update TP description
     * Starts monitor component behavior for TP_RX_PCSCF_RAA_01
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT send AA-Request in case of session establishment for originating side after 200 OK with SDP is received."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a 200_Response_INVITE_with_SDP_offer
     *         from the IMS_S_CSCF_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the AAR containing
     *             Framed_IPv4_Address_AVP 
     *                 indicating value "IPv4_Address of UE_A",
     *             "or" Framed_IPv6_Address_AVP 
     *                 indicating value "IPv6_Address of UE_A",
     *             "one or more" Media_Component_Description_AVP containing
     *                 Media_Component_Number_AVP
     *                 Media_Type_AVP
     *                 Flow_Status_AVP
     *                     indicating value ENABLED '(2)'
     *                 Max_Requested_Bandwidth_DL_AVP
     *                 Max_Requested_Bandwidth_UL_AVP
     *                 RR_Bandwidth_AVP
     *                 RS_Bandwidth_AVP
     *                 Codec_Data_AVP
     *                 "one or more" Media_Subcomponent_Description_AVP containing
     *                     Flow_Number_AVP
     *                     Flow_Description_AVP
     *                 ;
     *             ;
     *         ;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_RAA_01(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { rAR_MSG := mw_RAR_SpecificAction };
            var template DIAMETER_MSG mw_diameter_msg_fail := { rAR_MSG := mw_RAR_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_RAA_01 - RAR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
            
            mw_diameter_msg_pass := { rAA_MSG := mw_RAA_Rx_resultCode };
            mw_diameter_msg_fail := { rAA_MSG := mw_RAA_basic };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_RAA_01 - RAA",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_RAA_01
}//end group g_PCSCF_RAA

group g_PCSCF_STR {

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_STR_01
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT after reception of BYE sends an ST-Request at originating leg."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A and 
     *     the UE_A entity previouslyEstablishedCallWith the UE_B
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a BYE
     *         from the UE_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the STR containing
     *             Session_Id_AVP;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_STR_01(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { sTR_MSG := mw_STR_basic };
            var template DIAMETER_MSG mw_diameter_msg_fail := { sTR_MSG := mw_STR_dummy };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_STR_01 - STR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_STR_01

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_STR_02
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT after reception of BYE sends an ST-Request at terminating leg.
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_B entity isAttachedTo the EPC_B and
     *     the UE_B entity isRegisteredTo the IMS_B and 
     *     the UE_B entity previouslyEstablishedCallWith the UE_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_B entity receives a BYE
     *         from the IMS_S_CSCF_B entity
     *     }
     *     then {
     *         the IMS_P_CSCF_B entity sends the STR containing
     *             Session_Id_AVP;
     *         to the EPC_PCRF_B entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_STR_02(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { sTR_MSG := mw_STR_basic };
            var template DIAMETER_MSG mw_diameter_msg_fail := { sTR_MSG := mw_STR_dummy };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_STR_02 - STR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_STR_02

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_STR_03
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT after reception of CANCEL sends an ST-Request at originating leg."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a CANCEL
     *         from the UE_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the STR containing
     *             Session_Id_AVP;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_STR_03(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { sTR_MSG := mw_STR_basic };
            var template DIAMETER_MSG mw_diameter_msg_fail := { sTR_MSG := mw_STR_dummy };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_STR_03 - STR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_STR_03
    
    /**
     * Starts monitor component behavior for TP_RX_PCSCF_STR_04
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT after reception of CANCEL sends an ST-Request at terminating leg."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_B entity isAttachedTo the EPC_B and
     *     the UE_B entity isRegisteredTo the IMS_B
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_B entity receives a CANCEL
     *         from the IMS_S_CSCF_B entity
     *     }
     *     then {
     *         the IMS_P_CSCF_B entity sends the STR containing
     *             Session_Id_AVP;
     *         to the EPC_PCRF_B entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_STR_04(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { sTR_MSG := mw_STR_basic };
            var template DIAMETER_MSG mw_diameter_msg_fail := { sTR_MSG := mw_STR_dummy };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_STR_04 - STR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_STR_04
   
    /**
     * Starts monitor component behavior for TP_RX_PCSCF_STR_05
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT after reception of 486 response sends an ST-Request at originating leg."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a 486_Response_INVITE
     *         from the IMS_S_CSCF_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the STR containing
     *             Session_Id_AVP;
     *         to the EPC_PCRF_A entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_STR_05(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { sTR_MSG := mw_STR_basic };
            var template DIAMETER_MSG mw_diameter_msg_fail := { sTR_MSG := mw_STR_dummy };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_STR_05 - STR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_STR_05

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_STR_06
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT after reception of 486 response sends an ST-Request at terminating leg."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_B entity isAttachedTo the EPC_B and
     *     the UE_B entity isRegisteredTo the IMS_B
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_B entity receives a 486_Response_INVITE
     *         from the IMS_S_CSCF_B entity
     *     }
     *     then {
     *         the IMS_P_CSCF_B entity sends the STR containing
     *             Session_Id_AVP;
     *          to the EPC_PCRF_B entity
     *     } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_STR_06(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { sTR_MSG := mw_STR_basic };
            var template DIAMETER_MSG mw_diameter_msg_fail := { sTR_MSG := mw_STR_dummy };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_STR_06 - STR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
    } // End of function f_mtc_check_TP_RX_PCSCF_STR_06

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_STR_07
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT after reception of 200 response REGISTER sends an ST-Request."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a 200_Response_REGISTER
     *         from the IMS_S_CSCF_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the STR containing
     *             Session_Id_AVP;
     *         to the EPC_PCRF_A entity
     *    } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_STR_07(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { sTR_MSG := mw_STR_basic };
            var template DIAMETER_MSG mw_diameter_msg_fail := { sTR_MSG := mw_STR_dummy };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_STR_07 - STR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
  } // End of function f_mtc_check_TP_RX_PCSCF_STR_07

    /**
     * Starts monitor component behavior for TP_RX_PCSCF_STR_08
     * @param p_monitorCompRef Reference to monitor component
     * @param p_checkMessage indicate if the incomming message should only be checked (port.check) or consumed (port.receive). 
     * The check operation allows read access to the top element of incoming port queues without removing the top element from the queue.
     * <pre>
     * Test objective  "Verify that IUT after reception of NOTIFY during administrative de-registration sends an ST-Request."
     *
     * <pre>
     * 
     * Config Id CF_VxLTE_INT
     * 
     * Initial conditions with {
     *     the UE_A entity isAttachedTo the EPC_A and
     *     the UE_A entity isRegisteredTo the IMS_A
     * }
     * 
     * ensure that {
     *     when {
     *         the IMS_P_CSCF_A entity receives a NOTIFY
     *         from the IMS_S_CSCF_A entity
     *     }
     *     then {
     *         the IMS_P_CSCF_A entity sends the STR containing
     *             Session_Id_AVP;
     *         to the EPC_PCRF_A entity
     *    } 
     * } 
     * </pre>
     * @see TS 103 653-1 clause 7.6
     */
    function f_mtc_check_TP_RX_PCSCF_STR_08(
        DiameterInterfaceMonitor p_monitorCompRef,
        in boolean p_checkMessage := false,
        in boolean p_forward_to_mtc := false
    ) runs on ImsTestCoordinator {
        if (isvalue(p_monitorCompRef)){
            var template DIAMETER_MSG mw_diameter_msg_pass := { sTR_MSG := mw_STR_basic };
            var template DIAMETER_MSG mw_diameter_msg_fail := { sTR_MSG := mw_STR_dummy };
            p_monitorCompRef.start (
                f_Iot_Diameter_receive(
                    {
                        mw_diameter_msg_pass
                    },
                    {
                        mw_diameter_msg_fail
                    },
                    {0, omit},
                    "TP_RX_PCSCF_STR_08 - STR",
                    p_forward_to_mtc,
                    p_checkMessage 
                )
            );
            p_monitorCompRef.done;
        }
  } // End of function f_mtc_check_TP_RX_PCSCF_STR_08

} // end group g_PCSCF_STR

} // end group g_PCSCF


} // end module AtsImsIot_TP_behavior_RX