LibSip_Steps.ttcn

                        }
                    }
                }
            }
            return v_result;
        }

        /**
         * @desc copy media/attribute lines from remote to local SDP variable
         */
        function f_copy_SDP(
        ) runs on SipComponent  {
            if (isvalue(vc_sdp_remote.connection)) {
                vc_sdp_local.connection := vc_sdp_remote.connection;
            }
            else {
                vc_sdp_local.connection := omit;
            }

            vc_sdp_local.origin := vc_sdp_remote.origin;
            vc_sdp_local.session_name := vc_sdp_remote.session_name;

            if (isvalue(vc_sdp_remote.bandwidth)) {
                vc_sdp_local.bandwidth := vc_sdp_remote.bandwidth;
            }
            else {
                vc_sdp_local.bandwidth := {};
            }

            if (isvalue(vc_sdp_remote.media_list)) {
                // // cleaning of media before assignment
                // if (isvalue(vc_sdp_local.media_list))
                // {
                //                      for (var integer i:=0; i<lengthof(vc_sdp_local.media_list); i:=i+1)
                // {
                // vc_sdp_local.media_list[i ] := omit ;
                // }
                // };
                vc_sdp_local.media_list := vc_sdp_remote.media_list;
            }
        }


    } // end group SDPOperations

    group AwaitingMessage {

        /**
         * @desc Function for time delay
         */
        function f_awaitingDelayTimer(
            float p_delay
        ) runs on SipComponent  {
            tc_tDelay.start(p_delay);
            alt {
                [] tc_tDelay.timeout {
                    setverdict(pass);
                }
            }
        } // end f_awaitingDelayTimer

        /**
         * @desc Function waiting for any MSG -request/response
         */
        function f_awaitingAnyPassOnTimeout(
        ) runs on SipComponent  {
            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive
                {
                    tc_wait.stop;
                    vc_boo_response := true;
                    vc_boo_request := true;
                // setverdict(pass)
                }
                [] tc_wait.timeout {
                    vc_boo_response := false;
                    vc_boo_request := false;
                // setverdict (pass)
                }
            }
        } // end f_awaitingResponsePassOnTimeout

        /**
         * @desc Function waiting for no MSG -request/response
         */
        function f_awaitingNonePassOnTimeout(
        ) runs on SipComponent  {
            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] tc_wait.timeout {
                    setverdict(pass);
                }
            }
        } // end f_awaitingNonePassOnTimeout

        /**
         * @desc function awaits REGISTER
         * @param p_register expected REGISTER request
         */
        function f_awaitingREGISTER(
            in template(present) REGISTER_Request p_register := ?
        ) runs on SipComponent  {
            var REGISTER_Request v_request;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_register) -> value v_request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfREGISTER(v_request);
                }
                [] tc_wait.timeout {
                    setverdict(fail);
                    f_componentStop();
                }
            }
        }

        /**
         * @desc function awaits SUBSCRIBE
         * @param p_register expected SUBSCRIBE request
         */
        function f_awaitingSUBSCRIBE(
            in template(present) SUBSCRIBE_Request p_subscribe := ?
        ) runs on SipComponent  {
            var SUBSCRIBE_Request v_request;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_subscribe) -> value v_request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfSUBSCRIBE(v_request);
                }
                [] SIPP.receive(mw_SUBSCRIBE_Request_Base) -> value v_request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    setverdict(fail);
                    f_setHeadersOnReceiptOfSUBSCRIBE(v_request);
                // f_send200OK();
                }
            }
        }

        /**
         * @desc function awaits REGISTER and sends a 200 OK response
         * @param p_reply flag used to avoid the 200OK response sending
         */
        function f_awaitingREGISTER_sendReply(
            in template(present) REGISTER_Request p_register := ?,
            in boolean p_reply
        ) runs on SipComponent  {
            var REGISTER_Request v_request;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_register) -> value v_request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    vc_request := v_request;
                    f_setHeadersOnReceiptOfREGISTER(v_request);
                    // Answer to the Request
                    if (p_reply) {
                        f_send200OK();
                    }
                }
                [] tc_wait.timeout {
                    setverdict(fail);
                    f_componentStop();
                }
            }
        }


        /**
         * @desc Function waiting for a 200 OK response
         * @param p_cSeq_s current cSeq expectation
         */
        function f_awaitingOkResponse(
            inout CSeq p_cSeq_s
        ) runs on SipComponent  {

            tc_resp.start;
            alt {
                [] SIPP.receive(mw_Response_Base(c_statusLine200, vc_callId, p_cSeq_s)) -> value vc_response {
                    tc_resp.stop;
                    f_setHeadersOnReceiptOfResponse(vc_response);
                    setverdict(pass);
                }
            }
        } // end awaitingOkResponse

        /**
         * @desc Function waiting for a response
         * @param p_Response expected response message
         */
        function f_awaitingResponse(
            in template(present) Response p_Response := ?
        ) runs on SipComponent  {
            tc_resp.start;
            a_awaitingResponse(p_Response);
        } // end f_awaitingResponse

        altstep a_awaitingResponse(
            in template(present) Response p_Response := ?
        ) runs on SipComponent {
            [] SIPP.receive(p_Response) -> value vc_response {
                tc_resp.stop;
                f_setHeadersOnReceiptOfResponse(vc_response);
            // setverdict(pass)
            }
        } // end f_awaitingResponse

        /**
         * @desc Function waiting for a response, repeat if 100 Trying is received
         * @param p_Response expected response message
         */
        function f_awaitingResponseIgnore100Trying(
            in template(present) Response p_Response := ?
        ) runs on SipComponent  {
            tc_resp.start;
            alt {
                [] SIPP.receive(p_Response) -> value vc_response {
                    tc_resp.stop;
                    f_setHeadersOnReceiptOfResponse(vc_response);
                // setverdict(pass)
                }
                [] SIPP.receive(mw_Response_Base(c_statusLine100, vc_callId, vc_cSeq)) -> value vc_response {
                    repeat;
                }
            }
        } // end f_awaitingResponseIgnore100Trying

        /**
         * @desc Function waiting for a response and send ACK on FailureResponses 4xx,5xx,6xx
         * @param p_Response expected response message
         */
        function f_awaitingResponseSendACK(
            in template(present) Response p_Response := ?
        ) runs on SipComponent  {
            tc_resp.start;
            alt {
                [] SIPP.receive(p_Response) -> value vc_response {
                    tc_resp.stop;
                    f_setHeadersOnReceiptOfResponse(vc_response);
                    LibSip_Steps.f_setHeadersACK();
                    f_SendACK(m_ACK_Request_Base(vc_requestUri, vc_callId, vc_cSeq, vc_from, vc_to, vc_via));
                    setverdict(pass);
                }
            }
        } // end f_awaitingResponse

        /**
         * @desc Function waiting for a response
         * @param p_Response expected response message
         */
        function f_awaitingResponsePassOnTimeout(
            in template(present) Response p_Response := ?
        ) runs on SipComponent  {
            tc_resp.start;
            alt {
                [] SIPP.receive(p_Response) -> value vc_response {
                    tc_resp.stop;
                    f_setHeadersOnReceiptOfResponse(vc_response);
                    vc_boo_response := true;
                // setverdict(pass)
                }
                [] tc_resp.timeout {
                    vc_boo_response := false;
                // setverdict (pass)
                }
            }
        } // end f_awaitingResponsePassOnTimeout

        /**
         * @desc Function waiting for a 200 OK response
         * @param p_cSeq_s current cSeq expectation
         */
        function f_awaitingOkResponseAndNOTIFY_sendReply(
            inout CSeq p_cSeq_s,
            in template(present) NOTIFY_Request p_MSG := ?
        ) runs on SipComponent  {

            var boolean v_received_OK := false;
            var boolean v_received_NOTIFY := false;
            var NOTIFY_Request v_MSG;
            tc_resp.start;
            tc_wait.start(PX_SIP_TWAIT);

            log(">>> function f_awaitingOkResponseAndNOTIFY_sendReply: ", vc_sent_label);
            alt {
                [] SIPP.receive(mw_Response_Base(c_statusLine200, vc_callId, p_cSeq_s)) -> value vc_response {
                    tc_resp.stop;
                    vc_subscribed := true;
                    f_setHeadersOnReceiptOfResponse(vc_response);
                    v_received_OK := true;
                    setverdict(pass);
                    if (not (v_received_NOTIFY)) {
                        repeat;
                    }
                }
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_getRouteMapIntoRecordRoute(v_MSG);
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                    // Answer to the NOTIFY
                    f_send200OK();
                    v_received_NOTIFY := true;
                    if (not (v_received_OK)) {
                        repeat;
                    }
                }
            }
        } // end f_awaitingOkResponseAndNOTIFY_sendReply

        /**
         * @desc await INFO request reply with 200 OK
         */
        function f_awaitingINFO_sendReply(
            in template(value) INFO_Request p_info
        ) runs on SipComponent  {
            var INFO_Request v_request;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_info) -> value v_request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_request);
                    // Answer to the INFO
                    f_send200OK();
                }
            }
        } // end of f_awaitingINFO_sendReply

        /**
         * @desc function awaiting for an incoming INVITE
         * @param p_request expected message
         */
        function f_awaitingINVITE(
            template(present) INVITE_Request p_request := ?
        ) runs on SipComponent  {
            var INVITE_Request v_INVITE_Request;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_request) -> value v_INVITE_Request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    vc_ignore_invite := true;
                    vc_first_recv := true; // communication has started
                    f_setHeadersOnReceiptOfINVITE(v_INVITE_Request);
                    SIPP.send(m_Response_Base(c_statusLine100, vc_callId, vc_cSeq, vc_from, vc_to, vc_via)) to vc_sent_label;
                }
                [vc_interface_isc] SIPP.receive(mw_INVITE_Request_Base) -> value v_INVITE_Request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    setverdict(fail);
                    f_setHeadersOnReceiptOfINVITE(v_INVITE_Request);
                    SIPP.send(m_Response_Base(c_statusLine100, vc_callId, vc_cSeq, vc_from, vc_to, vc_via)) to vc_sent_label;
                    // clear session - send 486 and await ACK
                    f_sendResponse(m_Response_Base(c_statusLine486, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via));
                    f_awaitingACK(mw_ACK_Request_Base(?));
                    // await 486 which go towards and send ACK
                    f_awaitingResponse(mw_Response_Base(c_statusLine486, ?, ?));
                    f_SendACK(m_ACK_Request_Base(vc_requestUri, vc_callId, vc_cSeq, vc_from, vc_to, vc_via));
                    syncPort.send(m_syncClientStop);
                    stop;
                }
            }
        } // end f_awaitingINVITE

        /**
         * @desc function awaiting for an incoming INVITE
         * @param p_request expected message
         */
        function f_awaitingINVITE_No100Response(
            template(present) INVITE_Request p_request := ?
        ) runs on SipComponent  {
            var INVITE_Request v_INVITE_Request;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_request) -> value v_INVITE_Request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    vc_ignore_invite := true;
                    vc_first_recv := true; // communication has started
                    f_setHeadersOnReceiptOfINVITE(v_INVITE_Request);
                // SIPP.send(m_Response_Base(c_statusLine100, vc_callId, vc_cSeq, vc_from, vc_to, vc_via)) to vc_sent_label;
                }
            }
        } // end f_awaitingInviteRequest

        /**
         * @desc function awaiting for an incoming INVITE
         * @param p_request expected message
         */
        function f_awaitingINVITE_PassOnTimeout(
            template(present) INVITE_Request p_request := ?
        ) runs on SipComponent  {
            var INVITE_Request v_INVITE_Request;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_request) -> value v_INVITE_Request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    vc_ignore_invite := true;
                    vc_first_recv := true; // communication has started
                    vc_boo_request := true;
                    f_setHeadersOnReceiptOfINVITE(v_INVITE_Request);
                    SIPP.send(m_Response_Base(c_statusLine100, vc_callId, vc_cSeq, vc_from, vc_to, vc_via)) to vc_sent_label;
                }
                [] tc_wait.timeout {
                    vc_boo_request := false;
                }
            }
        } // end f_awaitingInviteRequest

        /**
         * @desc function awaiting ACK request
         */
        function f_awaitingACK(
            in template(present) ACK_Request p_ACK := ?
        ) runs on SipComponent  {
            f_awaitingACK_setHeaders(p_ACK, false);
        } // end f_awaitingACK

        /**
         * @desc function awaiting ACK request
         */
        function f_awaitingACK_setHeaders(
            in template(present) ACK_Request p_ACK := ?,
            in boolean p_setHeaders
        ) runs on SipComponent  {
            var ACK_Request v_ACK_Request;
            tc_ack.start;

            alt {
                [] SIPP.receive(p_ACK) -> value v_ACK_Request {
                    tc_ack.stop;
                    if (p_setHeaders) {
                        f_setHeadersOnReceiptOfRequest(v_ACK_Request);
                    }
                }
            }
        } // end f_awaitingACK_setHeaders

        /**
         * @desc function awaiting BYE and sending 200OK response
         * @param p_BYE expected BYE
         */
        function f_awaitingBYE(
            in template(present) BYE_Request p_BYE := ?
        ) runs on SipComponent  {
            var BYE_Request v_BYE_Request;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_BYE) -> value v_BYE_Request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    vc_ignore_bye := true;
                    f_setHeadersOnReceiptOfBYE(v_BYE_Request);
                // f_send200OK();
                }
            }
        } // end f_awaitingBYE

        /**
         * @desc function awaiting BYE and sending 200OK response
         * @param p_BYE expected BYE
         */
        function f_awaitingBYE_sendReply(
            in template(present) BYE_Request p_BYE := ?
        ) runs on SipComponent  {
            var BYE_Request v_BYE_Request;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_BYE) -> value v_BYE_Request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    vc_ignore_bye := true;
                    f_setHeadersOnReceiptOfBYE(v_BYE_Request);
                    f_send200OK();
                }
            }
        } // end f_awaitingBYE_sendReply

        /**
         * @desc function awaiting BYE and sending 200OK response
         * @param p_BYE expected BYE
         */
        function f_awaitingBYE_sendReply_PassOnTimeout(
            in template(present) BYE_Request p_BYE := ?
        ) runs on SipComponent  {
            var BYE_Request v_BYE_Request;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_BYE) -> value v_BYE_Request /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    vc_ignore_bye := true;
                    vc_boo_request := true;
                    f_setHeadersOnReceiptOfBYE(v_BYE_Request);
                    f_send200OK();
                }
                [] tc_wait.timeout {
                    vc_boo_request := false;
                }
            }
        } // end f_awaitingBYE_sendReply_PassOnTimeout

        /**
         * @desc function awaiting CANCEL
         * @param p_CANCEL expected CANCEL
         */
        function f_awaitingCANCEL(
            in template(present) CANCEL_Request p_CANCEL := ?
        ) runs on SipComponent  {
            var CANCEL_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_CANCEL) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                }
            }
        } // end f_awaitingCANCEL
        /**
         * @desc await MESSAGE request
         */
        function f_awaitingMESSAGE(
            in template(present) MESSAGE_Request p_MSG := ?
        ) runs on SipComponent  {
            var MESSAGE_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                }
                [] SIPP.receive(mw_MESSAGE_Request_Base) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                    log("*** " &__SCOPE__& ": INFO: Received MESSAGE not as expected! ***");
                    setverdict(fail);
                }
            }
        } // end of f_awaitingMESSAGE

        /**
         * @desc await MESSAGE request reply with 200 OK
         */
        function f_awaitingMESSAGE_sendReply(
        ) runs on SipComponent  {
            var MESSAGE_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(mw_MESSAGE_Request_Base) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                    // Answer to the MESSAGE
                    f_send200OK();
                }
            }
        } // end of f_awaitingMESSAGE_sendReply

        /**
         * @desc await MESSAGE request
         */
        function f_awaitingMESSAGE_sendReply_PassOnTimeout(
            in template(present) MESSAGE_Request p_MSG := ?
        ) runs on SipComponent  {
            var MESSAGE_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                    // Answer to the MESSAGE
                    // f_send200OK();
                    vc_boo_request := true;
                    f_send200OK();
                // setverdict (pass);
                }
                [] tc_wait.timeout {
                    vc_boo_request := false;
                // setverdict (pass);
                }
            }
        } // end of f_awaitingMESSAGE_PassOnTimeout

        /**
         * @desc await NOTIFY request
         */
        function f_awaitingNOTIFY(
            in template(present) NOTIFY_Request p_MSG := ?
        ) runs on SipComponent  {
            var NOTIFY_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_getRouteMapIntoRecordRoute(v_MSG);
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                }
            }
        } // end of f_awaitingNOTIFY

        /**
         * @desc await NOTIFY request reply with 200 OK
         */
        function f_awaitingNOTIFY_sendReply(
            in template(present) NOTIFY_Request p_MSG := ?
        ) runs on SipComponent  {
            var NOTIFY_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_getRouteMapIntoRecordRoute(v_MSG);
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                    // Answer to the NOTIFY
                    f_send200OK();
                }
            }
        } // end of f_awaitingNOTIFY_sendReply

        function f_awaitingNOTIFY_sendReply_postamble(
            in template(present) NOTIFY_Request p_MSG := ?
        ) runs on SipComponent  {
            var NOTIFY_Request v_MSG;

            tc_wait.start(5.0);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_getRouteMapIntoRecordRoute(v_MSG);
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                    // Answer to the NOTIFY
                    f_send200OK();
                }
                [] tc_wait.timeout {
                // do nothing as receiving the Notify in de-registration is not part of the test body
                }
            }
        } // end of f_awaitingNOTIFY_sendReply_postamble

        /**
         * @desc await PRACK request reply with 200 OK
         */
        function f_awaitingPRACK_sendReply(
            in template(present) PRACK_Request p_MSG := ?
        ) runs on SipComponent  {
            var PRACK_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                    // Answer to the PRACK
                    if (isvalue(vc_request.messageBody) and ischosen(vc_request.messageBody.sdpMessageBody)) {
                        f_sendResponse(m_Response_mbody(c_statusLine200, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via, omit, f_recordroute(), m_MBody_SDP(vc_sdp_local)));
                    }
                    else {
                        f_sendResponse(m_Response_ext(c_statusLine200, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via, omit, f_recordroute()));
                    }
                }
            }
        } // end of f_awaitingPRACK_sendReply

        function f_awaitingPRACK(
            in template(present) PRACK_Request p_MSG := ?
        ) runs on SipComponent  {
            var PRACK_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                }
            }
        } // end of f_awaitingPRACK

        /**
         * @desc await PUBLISH request reply with 200 OK
         */
        function f_awaitingPUBLISH_sendReply(
            in template(present) PUBLISH_Request p_MSG := ?
        ) runs on SipComponent  {
            var PUBLISH_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                    // Answer to the PUBLISH
                    f_send200OK();
                }
            }
        } // end of f_awaitingPUBLISH_sendReply

        /**
         * @desc await UPDATE request
         */
        function f_awaitingUPDATE(
            in template(present) UPDATE_Request p_MSG := ?
        ) runs on SipComponent  {
            var UPDATE_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                }
            }
        } // end of f_awaitingUPDATE

        /**
         * @desc await UPDATE request reply with 200 OK
         */
        function f_awaitingUPDATE_sendReply(
            in template(present) UPDATE_Request p_MSG := ?
        ) runs on SipComponent  {
            var UPDATE_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfRequest(v_MSG);
                    // Answer to the UPDATE
                    if (isvalue(vc_request.messageBody) and ischosen(vc_request.messageBody.sdpMessageBody)) {
                        f_sendResponse(m_Response_mbody(c_statusLine200, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via, omit, f_recordroute(), m_MBody_SDP(vc_sdp_local)));
                    }
                    else {
                        f_sendResponse(m_Response_ext(c_statusLine200, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via, omit, f_recordroute()));
                    }
                }
            }
        } // end of f_awaitingUPDATE_sendReply


        /**
         * @desc await REFER request
         */
        function f_awaitingREFER(
            in template(present) REFER_Request p_MSG := ?
        ) runs on SipComponent  {
            var REFER_Request v_MSG;

            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive(p_MSG) -> value v_MSG /*TODO Dynami error: sender vc_sent_label*/ {
                    tc_wait.stop;
                    f_setHeadersOnReceiptOfREFER(v_MSG);
                }
            }
        } // end of f_awaitingUPDATE



    } // end AwaitingMessage

    group SendMessage {

        /**
         * @desc send ACK message, update the route and recordRoute header fields depending on boolean flags
         * @param p_request template of the message to be sent
         */
        function f_SendACK(
            template(value) ACK_Request p_request
        ) runs on SipComponent  {
            // p_request.msgHeader.route := f_route(); // update the route header field depending on vc_boo_route
            // n/a p_request.msgHeader.recordRoute := f_recordroute(); // update the route header field depending on vc_boo_route
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc send BYE message, update the route and recordRoute header fields depending on boolean flags
         * @param p_request template of the message to be sent
         */
        function f_SendBYE(
            template(value) BYE_Request p_request
        ) runs on SipComponent  {
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc send CANCEL message
         * @param p_request template of the message to be sent
         */
        function f_SendCANCEL(
            template(value) CANCEL_Request p_request
        ) runs on SipComponent  {
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc send INFO message
         * @param p_request template of the message to be sent
         */
        function f_SendINFO(
            template(value) INFO_Request p_request
        ) runs on SipComponent  {
            f_setHeadersGeneral(vc_cSeq, "INFO"); // cseq, contact, branch, via
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc send INVITE message
         * @param p_request template of the message to be sent
         */
        function f_SendINVITE(
            template(value) INVITE_Request p_request
        ) runs on SipComponent  {
            vc_requestFor407 := valueof(p_request);
            SIPP.send(p_request) to vc_sent_label;
            vc_request := vc_requestFor407;
            if (PX_SIP_INVITE_AUTHENTICATION_ENABLED) {
                a_altstep_401or407();
            }
        }

        /**
         * @desc send PRACK message
         * @param p_request template of the message to be sent
         */
        function f_SendPRACK(
        ) runs on SipComponent  {
            var integer responseNum := 1;
            var PRACK_Request prackReq;
            if (isvalue(vc_response.msgHeader.rSeq) and 
                        isvalue(vc_response.msgHeader.rSeq.responseNum)){
                responseNum := vc_response.msgHeader.rSeq.responseNum;
            }
            vc_rAck := valueof(m_RAck(vc_response.msgHeader.rSeq.responseNum, vc_cSeq.seqNumber, vc_cSeq.method));
            f_setHeadersGeneral(vc_cSeq, "PRACK"); // cseq, contact, branch, via
            prackReq := valueof(m_PRACK_Request_Base(vc_requestUri, vc_callId, vc_cSeq, vc_from, vc_to, vc_via, vc_rAck));
            if (isvalue(vc_response.msgHeader.recordRoute)){
                prackReq.msgHeader.route := valueof(f_route());
            }
            SIPP.send(prackReq) to vc_sent_label;
        }

        /**
         * @desc send PUBLISH message
         * @param p_request template of the message to be sent
         */
        function f_SendPUBLISH(
            template(value) PUBLISH_Request p_request
        ) runs on SipComponent  {
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc send REGISTER message
         * @param p_request template of the message to be sent
         */
        function f_SendREGISTER(
            template(value) REGISTER_Request p_request
        ) runs on SipComponent  {
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc send SUBSCRIBE message
         * @param p_request template of the message to be sent
         */
        function f_SendSUBSCRIBE(
            template(value) SUBSCRIBE_Request p_request
        ) runs on SipComponent  {
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc send UPDATE message
         * @param p_request template of the message to be sent
         */
        function f_SendUPDATE(
            template(value) UPDATE_Request p_request
        ) runs on SipComponent  {
            f_setHeadersGeneral(vc_cSeq, "UPDATE"); // cseq, contact, branch, via
            p_request.msgHeader.cSeq := vc_cSeq;
            p_request.msgHeader.contact := vc_contact;
            p_request.msgHeader.via := vc_via;
            vc_requestFor407 := valueof(p_request);
            SIPP.send(p_request) to vc_sent_label;
            if (PX_SIP_INVITE_AUTHENTICATION_ENABLED) {
                a_altstep_401or407();
            }
        }

        /**
         * @desc function send MESSAGE message
         * @param p_request template of the message to be sent
         */
        function f_SendMESSAGE(
            template(value) MESSAGE_Request p_request
        ) runs on SipComponent  {
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc function send NOTIFY message
         * @param p_request template of the notify to be sent
         */
        function f_SendNOTIFY(
            template(value) NOTIFY_Request p_request
        ) runs on SipComponent  {
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc function send OPTIONS message
         * @param p_request template of the notify to be sent
         */
        function f_SendOPTIONS(
            template(value) OPTIONS_Request p_request
        ) runs on SipComponent  {
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc send REFER message
         * @param p_request template of the message to be sent
         */
        function f_SendREFER(
            template(value) REFER_Request p_request
        ) runs on SipComponent  {
            SIPP.send(p_request) to vc_sent_label;
        }

        /**
         * @desc send 200 OK
         */
        function f_send200OK(
        ) runs on SipComponent  {
          log(">>> f_send200OK");
            f_sendResponse(m_Response_Base(c_statusLine200, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via));
        }

        /**
         * @desc send response
         * @param p_request template of the message to be sent
         */
        function f_sendResponse(
            template(value) Response p_response
        ) runs on SipComponent  {
            p_response.msgHeader.route := f_route(); // update the route header field depending on vc_boo_route
            p_response.msgHeader.recordRoute := f_recordroute(); // update the route header field depending on vc_boo_route
            SIPP.send(p_response) to vc_sent_label;
        }



    } // end SendMessage

    group GlobalSteps {
        /**
         * @desc component initialization
         * @param p_cSeq_s cSeq value to be assigned to the component variable
         */
        function f_init_component(
            inout CSeq p_cSeq_s
        ) runs on SipComponent  {
            // Variables
            vc_cSeq := p_cSeq_s;

            // Defaults
            vc_def_catchSyncStop := activate(a_Sip_catchSyncStop());
            vc_default := activate(a_clearRegistration());
        }

        /**
         * @desc component termination
         */
        function f_terminate_component(
        ) runs on SipComponent  {
            log("*** " &__SCOPE__& ": INFO: component terminated - forced! ***");
            deactivate;
            stop;
        }

        /**
         * @desc component termination
         */
        function f_componentStop(
        ) runs on SipComponent  {
            syncPort.send(m_syncClientStop);
            SIPP.clear;
            stop;
        }

        /**
         * @desc function waits for particular time that allows the SUT to return to idle state
         */