Index: trunk/ETSI-Testsuites/.project =================================================================== --- trunk/ETSI-Testsuites/.project (revision 18) +++ trunk/ETSI-Testsuites/.project (revision 18) @@ -0,0 +1,11 @@ + + + ETSI-Testsuites + + + + + + + + Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_Behavior.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_Behavior.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_Behavior.ttcn (revision 18) @@ -0,0 +1,4199 @@ +/** + * @author STF 370 + * @version $Id: $ + * @desc This module provides common functions which describes behavior for each TP reference. + */ +module AtsImsIot_Behavior { + + import from AtsImsIot_TestSystem { + type ImsInterfaceMonitor, ImsTestCoordinator; + } + + import from LibIot_PIXITS {modulepar PX_MAX_MSG_WAIT;} + + import from AtsImsIot_Templates {template all;} + + import from AtsImsIot_TypesAndValues { + type SipMessage, SipMessageList, SkipType; + } + + + import from LibIms_UpperTester {type ImsUserInfo;} + + import from LibIot_TypesAndValues {type SetFilterReq, SetFilterRsp;} + import from LibIot_Functions { + function f_setConformanceVerdict, f_setIotVerdictFAIL; + } + + import from LibSip_SIPTypesAndValues all; + + import from LibSip_Templates all; + + import from AtsImsIot_Functions all; + import from LibIot_PIXITS {modulepar PX_EUT_A, PX_EUT_B;} + +group checks { + +group checksTC_IMS_MESS_0001{ + + /** + * @desc + * TP_IMS_4002_01 in CFW step 3 (MESSAGE)
ensure that {
+ * when { UE_A sends a MESSAGE to UE_B containing a Message_Body + * greater than 1300 bytes }
then { IMS_B receives the MESSAGE + * containing the Message_Body greater than 1300 bytes }
} + */ + function f_mtc_check_TP_IMS_4002_01_gm(ImsInterfaceMonitor p_monitorCompRef) + runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_4002_01(?))},//? CallId can be checked + {mw_SipRequest(mw_MESSAGE_Request_Base(?))}, + {0,omit}, + "TP_IMS_4002_01_gm", + false, + false + ) + ); + p_monitorCompRef.done; + } + + function f_mtc_check_TP_IMS_4002_01_ic(ImsInterfaceMonitor p_monitorCompRef) + runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_4002_01(?))},//? CallId can be checked + {mw_SipRequest(mw_MESSAGE_Request_Base(?))}, + {0, omit}, + "TP_IMS_4002_01_ic", + false, + false + ) + ); + p_monitorCompRef.done; + } +} // group + + group checksTC_IMS_REG_0001 { + /** + * @desc Starts monitor component behavior for TP_IMS_5011_01 + * the on Gm-interface + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5011_01_gm( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5011_01_gm)}, + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {0, omit}, + "TP_IMS_5011_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5011_01 + * on the Mw-interface + * @param p_monitorCompRef Reference to monitor component + */ + + function f_mtc_check_TP_IMS_5011_01_ic( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + var charstring v_EUT_A_Addr := f_GetEUTPcscfAddress(PX_EUT_A); + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5011_01p_ic(v_EUT_A_Addr))}, + { + mw_SipRequest(mdw_TP_IMS_5011_01f_ic), + mw_SipRequest(mw_REGISTER_Request_Base) + }, + {0, omit}, + "TP_IMS_5011_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5089_01 (gm) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5089_01_gm_when ( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5089_01_gm_when", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5011_02 (gm) + * the on Gm-interface + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5011_02_gm( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5011_02_gm)}, + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {0, omit}, + "TP_IMS_5011_02_gm", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5011_02 (mw) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5011_02_ic( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + var charstring v_EUT_A_Addr := f_GetEUTPcscfAddress(PX_EUT_A); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5011_02p_ic(v_EUT_A_Addr))}, + {mw_SipRequest(mdw_TP_IMS_5011_02f_ic), + mw_SipRequest(mw_REGISTER_Request_Base)}, + {0, omit}, + "TP_IMS_5011_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5089_01 (when) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5089_01_ic_when( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5089_01_ic_when)}, + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {0, omit}, + "TP_IMS_5089_01 (when)", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5089_01 (then) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5089_01_ic_then( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5089_01_ic)}, + {mw_SipResponse (mw_401Unauthorized_Base)}, + {0, omit}, + "TP_IMS_5089_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5092_01 (gm) + * the on Gm-interface + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5092_01_gm( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5011_02_gm)}, + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {0, omit}, + "TP_IMS_5092_01_gm", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5092_01 (when) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5092_01_ic_when( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5092_01_ic_when)}, + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {0, omit}, + "TP_IMS_5092_01 (when)", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5092_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5092_01_ic( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + var charstring v_EUT_A_Addr := f_GetEUTPcscfAddress(PX_EUT_A); + var template SipUrl v_eutBUri := mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_B)); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5092_01_ic(v_EUT_A_Addr, v_eutBUri))}, + {mw_SipResponse (mw_200OK_Base)}, + {0, omit}, + "TP_IMS_5092_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5044_01 (when) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5044_01_ic_when( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator return Response { + var template SipUrl v_eutBUri := mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_B)); + var SipMessage v_sip := {response := valueof(m_Response_Dummy)}; + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + {0, omit}, + "TP_IMS_5044_01 (when)", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + return v_sip.response; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5044_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5044_01_ic( + ImsInterfaceMonitor p_monitorCompRef, Response p_200OK, boolean p_checkMessage + ) runs on ImsTestCoordinator { + var charstring v_UEB_PublicId := f_GetUEPublicId(PX_EUT_B); + var template SipUrl v_eutAUri := mw_SipUrl_Host(f_GetEUTPcscfAddress(PX_EUT_A)); + var SipMessage v_sip := {request := valueof(m_INVITE_Dummy)}; + var charstring v_Epires200OK; + var charstring v_EpiresSubscribe; + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5044_01_ic(?, v_eutAUri, v_UEB_PublicId))}, + {mw_SipRequest(mw_SUBSCRIBE_Request_Base)}, + {0, omit}, + "TP_IMS_5044_01", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + // Check that the expires header is set to "a value greater than the one + // in the Expires_header of the 200_response" + + if(ispresent(p_200OK.msgHeader.expires)) { + v_Epires200OK := p_200OK.msgHeader.expires.deltaSec; + v_EpiresSubscribe := v_sip.request.msgHeader.expires.deltaSec; + if (str2int(v_EpiresSubscribe) > str2int(v_Epires200OK)) { + f_setIotVerdictFAIL("TP_IMS_5044_01 - Expires_header of subscribe is NOT greater than the Expires_header of 200_response."); + } + } + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5096_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5096_01_ic_when( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator return Request { + var SipMessage v_sip := {request := valueof(m_INVITE_Dummy)}; + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5096_01_ic_when)}, + {mw_SipRequest(mw_SUBSCRIBE_Request_Base)}, + {0, omit}, + "TP_IMS_5096_01 (when)", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + return v_sip.request; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5096_01 + */ + function f_mtc_check_TP_IMS_5096_01_ic( + ImsInterfaceMonitor p_monitorCompRef, Request p_Subscribe, boolean p_checkMessage + ) runs on ImsTestCoordinator + { + var SipMessage v_sip := {request := valueof(m_INVITE_Dummy)}; + var charstring v_Epires200OK; + var charstring v_EpiresSubscribe; + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base), mw_SipResponse(mw_202Accepted_Base)}, + {}, + {0, omit}, + "TP_IMS_5096_01", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + if(ispresent(v_sip.response.msgHeader.expires)) { + // Check that the message contains "Expires_header indicating the same or + // lower expiry time than specified in the initial SUBSCRIBE" + v_Epires200OK := v_sip.response.msgHeader.expires.deltaSec; + v_EpiresSubscribe := p_Subscribe.msgHeader.expires.deltaSec; + if (str2int(v_Epires200OK) <= str2int(v_EpiresSubscribe)) { + f_setIotVerdictFAIL("TP_IMS_5096_01 - - Expires_header Expires_header of 200_response is NOT the same or lower than the Expires_header of subscribe."); + } + } + } + + } // group + +group checksTC_IMS_REG_0002{ + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5203_01_gm( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + // Check that the UE sends any register + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5203_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5203_01_ic( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator return Request { + var SipMessage v_sip := {request := valueof(m_INVITE_Dummy)}; + + //Get first Register + //var charstring v_EUT_A_Addr := f_GetEUTAddress(PX_EUT_A); + var Request v_RegisterStep4, v_RegisterStep2; + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5203_01 first register", + true, + false + ) + ); + p_monitorCompRef.done; + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + v_RegisterStep2 := v_sip.request; + + //Get second Register + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5203_01 second register", + true, + false + ) + ); + p_monitorCompRef.done; + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + + // TODO: Currently we don't check anything, just that IMS-A sent 2 consecutive Registers + v_RegisterStep4 := v_sip.request; + return v_RegisterStep4; + } + +} // group + +group checksTC_IMS_REG_0002H{ + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5402_01_gm( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + // Check that the UE sends any register + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5203_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5402_01_ic( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator return Request { + var SipMessage v_sip := {request := valueof(m_INVITE_Dummy)}; + + //Get first Register + //var charstring v_EUT_A_Addr := f_GetEUTAddress(PX_EUT_A); + var Request v_RegisterStep4, v_RegisterStep2; + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5203_01 first register", + true, + false + ) + ); + p_monitorCompRef.done; + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + v_RegisterStep2 := v_sip.request; + + //Get second Register + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5203_01 second register", + true, + false + ) + ); + p_monitorCompRef.done; + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + v_RegisterStep4 := v_sip.request; + + // Check that IMS_A sends the original Register to + // another entrypoint of IMS-B + if (not (match (v_RegisterStep4.msgHeader, v_RegisterStep2.msgHeader))){ + // Headers differ + f_setIotVerdictFAIL("TP_IMS_5203_01"); + } + if (match (v_RegisterStep4.requestLine, v_RegisterStep4.requestLine)){ + // IMS-A used same entrypoint + f_setIotVerdictFAIL("TP_IMS_5203_01"); + } + return v_RegisterStep4; + } + + +} // group + group checksTC_IMS_REG_0003{ + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5129_01_gm( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + // Check that the UE sends any register + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5129_01 (gm)", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5129_01_ic_when( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + // Check that the IMS_A forwards register from UE_B + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5129_01 (mw-when)", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5129_01_ic( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + var SipMessage v_sip := {request := valueof(m_INVITE_Dummy)}; + p_monitorCompRef.start( + // Check that IMS_B responds with 403 forbidden + f_imsIot_receive( + {mw_SipResponse(mw_403Forbidden_Base)}, + {}, + {0, omit}, + "TP_IMS_5129_01 (mw)", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + } // group + + group checksTC_IMS_REG_0003H{ + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5411_01_gm( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + // Check that the UE sends any register + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5411_01 (gm)", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5411_01_ic_when( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + // Check that the IMS_A forwards register from UE_B + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5411_01 (mw-when)", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5411_01_ic( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_403Forbidden_Base)}, + {}, + {0, omit}, + "TP_IMS_5411_01 (mw)", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + } // group + +group checksTC_IMS_REG_0004 { + + /** + * @desc Starts monitor component behavior for TP_IMS_5088_01 (gm) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5088_01_gm( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5088_01_gm)}, + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {0, omit}, + "TP_IMS_5088_01 (gm)", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5088_01 (mw) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5088_01_ic( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + + var template SipUrl v_eutAUri := mw_SipUrl_Host(f_GetEUTPcscfAddress(PX_EUT_A)); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5088_01_ic(?, v_eutAUri))}, + {mw_SipRequest(mw_NOTIFY_Request_Base(*))}, + {0, omit}, + "TP_IMS_5088_01_ic", + false, + p_checkMessage + ) + ); + } + } // group + + group checksTC_IMS_REG_0005{ + /** + * @desc Starts monitor component behavior for TP_IMS_5093_01 (mw) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5093_01_UE_ic( + ImsInterfaceMonitor p_monitorCompRef, ImsUserInfo v_anyValidUser, boolean p_checkMessage + ) runs on ImsTestCoordinator { + + var template SipUrl v_request_uri := mw_SipUrl_Number(v_anyValidUser.publicId); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5093_01_UE_ic(?, v_request_uri))}, + {mw_SipRequest(mw_NOTIFY_Request_Base(?))}, + {0, omit}, + "TP_IMS_5093_01_ic", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5093_01 (mw) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5093_01_IMS_ic( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + + var template SipUrl v_request_uri := mw_SipUrl_Host(f_GetEUTPcscfAddress(PX_EUT_A)); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5093_01_IMS_ic(?, v_request_uri))}, + {mw_SipRequest(mw_NOTIFY_Request_Base(?))}, + {0, omit}, + "TP_IMS_5093_01_ic", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + } // end group + + group checksTC_IMS_REG_0006{ + + /** + * @desc Starts monitor component behavior for TP_IMS_5094_01 (mw) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5094_01_UE( + ImsInterfaceMonitor p_monitorCompRef, ImsUserInfo v_anyValidUser, boolean p_checkMessage + ) runs on ImsTestCoordinator { + + var template SipUrl v_request_uri := mw_SipUrl_Number(v_anyValidUser.publicId); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5094_01_UE(?, v_request_uri))}, + {mw_SipRequest(mw_NOTIFY_Request_Base(?))}, + {0, omit}, + "TP_IMS_5094_01_ic", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5094_01 (mw) + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5094_01_IMS( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + + var template SipUrl v_request_uri := mw_SipUrl_Host(f_GetEUTPcscfAddress(PX_EUT_A)); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5094_01_IMS_ic(?, v_request_uri))}, + {mw_SipRequest(mw_NOTIFY_Request_Base(?))}, + {0, omit}, + "TP_IMS_5094_01_ic", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + } // end group + +group checksTC_IMS_REG_0007 { + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5134_01_gm( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5134_01 (gm)", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5134_01_ic( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + var charstring v_IBPC := f_GetEUTIbcfAddress(PX_EUT_A); + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5134_01_ic(v_IBPC))}, + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {0, omit}, + "TP_IMS_5134_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + // fetch second register + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5134_01_ic(v_IBPC))}, + {mw_SipRequest(mw_REGISTER_Request_Base)}, + {0, omit}, + "TP_IMS_5134_01", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5405_01_gm( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_SUBSCRIBE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5405_01 (gm)", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5405_01_ic( + ImsInterfaceMonitor p_monitorCompRef, boolean p_checkMessage + ) runs on ImsTestCoordinator { + // check 1st SUBSCRIBE (step 10) + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5405_01_ic)}, + {mw_SipRequest(mw_SUBSCRIBE_Request_Base)}, + {0, omit}, + "TP_IMS_5405_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + // check 2nd SUBSCRIBE (step 15) + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5405_01_ic)}, + {mw_SipRequest(mw_SUBSCRIBE_Request_Base)}, + {0, omit}, + "TP_IMS_5405_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + } // group + + +group checksTC_IMS_CALL_0001 { + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5097_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var charstring v_EUT_A_Addr := f_GetEUTScscfAddress(PX_EUT_A); + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5097_01_ic((mw_SipUrl_Host(v_EUT_A_Addr), + mw_SipUrl_Host(f_GetEUTScscfIpAddress(PX_EUT_A))) ))}, + {}, + {0, omit}, + "TP_IMS_5097_01", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } //function + + /** + * @desc Starts monitor component behavior for TP_IMS_5097_02 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5097_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5097_02 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_02_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5097_02_ic(mw_SIP_URI_Base, mw_TEL_URI_Base))}, + {mw_SipRequest(mw_INVITE_Request_Base)}, + {0, omit}, + "TP_IMS_5097_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5097_04 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_04_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5097_04_gm(mw_TEL_URI_Base))},//TODO check TEL_URI of UE_B + {mw_SipRequest(mw_INVITE_Request_Base)}, + {0, omit}, + "TP_IMS_5097_04", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5097_04 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_04_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5097_04_ic(mw_SIP_URI_Base))},//TODO check SIP_URI of UE_B + {mw_SipRequest(mw_INVITE_Request_Base)}, + {0, omit}, + "TP_IMS_5097_04", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5107_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_ACK_Request_Base(?))}, + {}, + {0, omit}, + "TP_IMS_5107_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5107_02_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var charstring v_EUT_A_Addr := f_GetEUTScscfAddress(PX_EUT_A); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5107_02_ic(?, mw_SipUrl_Host(v_EUT_A_Addr)))}, + {}, + {0, omit}, + "TP_IMS_5107_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } //function + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5107_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_BYE_Request_Base(?))}, + {}, + {0, omit}, + "TP_IMS_5107_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5107_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var charstring v_EUT_A_Addr := f_GetEUTScscfAddress(PX_EUT_A); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5107_01_ic(?, mw_SipUrl_Host(v_EUT_A_Addr)))}, + {}, + {0, omit}, + "TP_IMS_5107_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } //function + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5115_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_180Ringing_Base)}, + {}, + {0, omit}, + "TP_IMS_5115_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5115_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5115_01_ic)}, + {mw_SipResponse(mw_180Ringing_Base)}, + {0, omit}, + "TP_IMS_5115_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5115_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + {0, omit}, + "TP_IMS_5115_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5115_02_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5115_02_ic)}, + {mw_SipResponse(mw_200OK_Base)}, + {0, omit}, + "TP_IMS_5115_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5115_03_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_180Ringing_Base)}, + {}, + {0, omit}, + "TP_IMS_5115_03", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5115_03_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5115_03_ic(mw_SIP_URI_Base, mw_TEL_URI_Base))}, + {mw_SipResponse(mw_180Ringing_Base)}, + {0, omit}, + "TP_IMS_5115_03", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5115_04_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + {0, omit}, + "TP_IMS_5115_04", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5115_04_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5115_04_ic(mw_SIP_URI_Base, mw_TEL_URI_Base))}, + {mw_SipResponse(mw_200OK_Base)}, + {0, omit}, + "TP_IMS_5115_04", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5131_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_180Ringing_Base)}, + {}, + {0, omit}, + "TP_IMS_5131_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5131_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5131_01_ic)}, + {mw_SipResponse(mw_180Ringing_Base)}, + {0, omit}, + "TP_IMS_5131_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5131_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + {0, omit}, + "TP_IMS_5131_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5131_02_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5131_02_ic)}, + {mw_SipResponse(mw_200OK_Base)}, + {0, omit}, + "TP_IMS_5131_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + +} // group + +group checksTC_IMS_CALL_0001F { + +/*functions already used in test TC_IMS_CALL_0001 + * f_mtc_check_TP_IMS_5097_01_gm + * f_mtc_check_TP_IMS_5097_01_ic + * f_mtc_check_TP_IMS_5107_01_gm + * f_mtc_check_TP_IMS_5107_01_ic + * f_mtc_check_TP_IMS_5107_02_gm + * f_mtc_check_TP_IMS_5107_02_ic + * f_mtc_check_TP_IMS_5115_01_gm + * f_mtc_check_TP_IMS_5115_01_ic + * f_mtc_check_TP_IMS_5115_02_gm + * f_mtc_check_TP_IMS_5115_02_ic + * f_mtc_check_TP_IMS_5131_01_gm + * f_mtc_check_TP_IMS_5131_01_ic + * f_mtc_check_TP_IMS_5131_02_gm + * f_mtc_check_TP_IMS_5131_02_ic + * +*/ +} // group + +group checksTC_IMS_CALL_0002 { + +/*functions already used in test TC_IMS_CALL_0001 + * f_mtc_check_TP_IMS_5097_01_gm + * f_mtc_check_TP_IMS_5097_01_ic + * f_mtc_check_TP_IMS_5097_02_gm + * f_mtc_check_TP_IMS_5097_02_ic + * f_mtc_check_TP_IMS_5107_01_gm + * f_mtc_check_TP_IMS_5107_01_ic + * f_mtc_check_TP_IMS_5107_02_gm + * f_mtc_check_TP_IMS_5107_02_ic + * f_mtc_check_TP_IMS_5115_01_gm + * f_mtc_check_TP_IMS_5115_01_ic + * f_mtc_check_TP_IMS_5115_02_gm + * f_mtc_check_TP_IMS_5115_02_ic + * f_mtc_check_TP_IMS_5115_03_gm + * f_mtc_check_TP_IMS_5115_03_ic + * f_mtc_check_TP_IMS_5115_04_gm + * f_mtc_check_TP_IMS_5115_04_ic + * f_mtc_check_TP_IMS_5131_01_gm + * f_mtc_check_TP_IMS_5131_01_ic + * f_mtc_check_TP_IMS_5131_02_gm + * f_mtc_check_TP_IMS_5131_02_ic + * +*/ +} // group + +group checksTC_IMS_CALL_0003 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5108_05_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5108_05", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5108_05_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5108_05", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_404NotFound_Base)}, + {}, + {0, omit}, + "TP_IMS_5108_05", + false, + false + ) + ); + p_monitorCompRef.done; + + } //function + +} // group + +group checksTC_IMS_CALL_0004 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5132_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5132_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5132_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5132_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_404Or604NotFound_Base)}, + {}, + {0, omit}, + "TP_IMS_5132_01", + false, + false + ) + ); + p_monitorCompRef.done; + + } //function + +} // group + +group checksTC_IMS_CALL_0005 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5133_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5133_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5133_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5133_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_4XX_Base)}, + {}, + {0, omit}, + "TP_IMS_5133_01", + false, + false + ) + ); + p_monitorCompRef.done; + + } //function + +} // group + +group checksTC_IMS_CALL_0006 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5109_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5109_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5109_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5109_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_408Or5XX_Base)}, + {}, + {0, omit}, + "TP_IMS_5109_01", + false, + false + ) + ); + p_monitorCompRef.done; + + } //function + +} // group + +group checksTC_IMS_CALL_0007 { + + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5055_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_180Ringing_Base)}, + {}, + {0, omit}, + "TP_IMS_5055_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5055_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_pcscfEutAUrl := mw_SipUrl_Host(f_GetEUTPcscfAddress(PX_EUT_A)); + var ImsUserInfo v_user := f_getAnyValidUser(PX_EUT_A); + var template SipUrl v_UserEutAUrl := mw_SipUrl_Host(v_user.domain); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5055_01_ic(v_pcscfEutAUrl, v_UserEutAUrl))}, + {mw_SipResponse(mw_180Ringing_Base)}, + {0, omit}, + "TP_IMS_5055_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5055_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + {0, omit}, + "TP_IMS_5055_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5055_02_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_pcscfEutAUrl := mw_SipUrl_Host(f_GetEUTPcscfAddress(PX_EUT_A)); + var ImsUserInfo v_user := f_getAnyValidUser(PX_EUT_A); + var template SipUrl v_UserEutAUrl := mw_SipUrl_Host(v_user.domain); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5055_02_ic(v_pcscfEutAUrl, v_UserEutAUrl))}, + {mw_SipResponse(mw_200OK_Base)}, + {0, omit}, + "TP_IMS_5055_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5067_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5067_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5067_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5067_01_ic)}, + {mw_SipRequest(mw_INVITE_Request_Base)}, + {0, omit}, + "TP_IMS_5067_01", + true, //NOTE: later check in 5108_01 of same icid value + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5070_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5070_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5070_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_100Trying_Base)}, + {}, + {0, omit}, + "TP_IMS_5070_01", + false, + false + ) + ); + p_monitorCompRef.done; + + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5108_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5108_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_SCSCF_IMS_B := mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_B)); + var SemicolonParam_List p_paramList; + var GenericParam p_param; + var SipMessage v_sip := {request := valueof(m_INVITE_Dummy)}; + + + + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); //NOTE: icid value from 5067_01 +log("### f_mtc_check_TP_IMS_5108_01_ic: v_sip=", v_sip.request.msgHeader.pChargingVector); + if(ispresent(v_sip.request.msgHeader.pChargingVector)) { + if(ispresent(v_sip.request.msgHeader.pChargingVector.chargeParams)) { +log("### f_mtc_check_TP_IMS_5108_01_ic: then"); + p_paramList := v_sip.request.msgHeader.pChargingVector.chargeParams; +log("### f_mtc_check_TP_IMS_5108_01_ic: p_paramList=", p_paramList); + for(var integer i := 0; i < lengthof(p_paramList); i:= i+1) { + if(p_paramList[i].id == "icid-value") { +log("### f_mtc_check_TP_IMS_5108_01_ic: find param=", p_paramList[i]); + p_param := p_paramList[i]; + break; + } + } + } + } +log("### f_mtc_check_TP_IMS_5108_01_ic: start"); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5108_01_ic(v_SCSCF_IMS_B, p_param))},//pass criteria + { + mw_SipRequest(mdw_TP_IMS_5108_01_f_ic), //fail criteria + mw_SipRequest(mw_INVITE_Request_Base) //fail criteria + }, + {0, omit}, + "TP_IMS_5108_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5301_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_BYE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5301_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5301_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_SCSCF_IMS_A := mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_A)); + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5301_01_ic(?, v_SCSCF_IMS_A))}, + {mw_SipRequest(mw_BYE_Request_Base(?))}, + {0, omit}, + "TP_IMS_5301_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + +} // group + +group checksTC_IMS_CALL_0008 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5081_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5081_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_100Trying_Base)}, + {}, + {0, omit}, + "TP_IMS_5081_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5082_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage, + integer p_skipCount + ) runs on ImsTestCoordinator { + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {1, mw_SipResponse(mw_200OK_Base)}; + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + v_skip, + "TP_IMS_5082_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5082_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage, + integer p_skipCount + ) runs on ImsTestCoordinator { + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {p_skipCount, mw_SipResponse(mw_200OK_Base)}; + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5082_01_ic)},//TODO check updated access-network-charging-info + {mw_SipResponse(mw_200OK_Base)}, + v_skip, + "TP_IMS_5082_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5120_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage, + integer p_skipCount + ) runs on ImsTestCoordinator { + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {1, mw_SipRequest(mw_INVITE_Request_Base)}; + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + v_skip, + "TP_IMS_5120_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5120_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage, + integer p_skipCount + ) runs on ImsTestCoordinator { + var template SipUrl v_scscfEutBUrl := mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_B)); + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {p_skipCount, mw_SipRequest(mw_INVITE_Request_Base)}; + } + + //INVITE from IMS_A to IMS_B + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + v_skip, + "TP_IMS_5120_01", + false, + false + ) + ); + p_monitorCompRef.done; + + // 100 Trying from IMS_B to IMS_A + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_100Trying_Base)}, + {}, + {0, omit}, + "TP_IMS_5120_01", + false, + false + ) + ); + p_monitorCompRef.done; + + // INVITE from IMS_B to IMS_A + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5120_01_ic(v_scscfEutBUrl))}, + {}, + {0, omit}, + "TP_IMS_5120_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + +} // group + +group checksTC_IMS_CALL_0009 { + + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5052_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_BYE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5052_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5052_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_PCSCF_IMS_A := mw_SipUrl_Host(f_GetEUTPcscfAddress(PX_EUT_A)); + var template RecordRoute p_recordRoute := omit; + var SipMessage v_sip := {request := valueof(m_ACK_Dummy)}; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_ACK_Request_Base(?))}, + {}, + {1, mw_SipRequest(mw_ACK_Request_Base(?))}, + "TP_IMS_5052_01", + true, + false + ) + ); + p_monitorCompRef.done; + + // get Record-route header from prev ACK + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + if(ispresent(v_sip.request.msgHeader.recordRoute)){ + p_recordRoute := v_sip.request.msgHeader.recordRoute; + } + + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5052_01_p_ic(?,p_recordRoute))}, + { + mw_SipRequest(mdw_TP_IMS_5052_01_f_ic(?, v_PCSCF_IMS_A)), + mw_SipRequest(mw_BYE_Request_Base(?)) + }, + {0, omit}, + "TP_IMS_5052_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + +} // group + +group checksTC_IMS_CALL_0010 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5048_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage, + integer p_skipCount + ) runs on ImsTestCoordinator { + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {1, mw_SipRequest(mw_INVITE_Request_Base)}; + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + v_skip, + "TP_IMS_5048_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5048_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage, + integer p_skipCount + ) runs on ImsTestCoordinator { + var template SipUrl v_pcscfEutAUrl := (mw_SipUrl_Host(f_GetEUTPcscfAddress(PX_EUT_A)), + mw_SipUrl_Host(f_GetEUTPcscfIpAddress(PX_EUT_A))); + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {p_skipCount, mw_SipRequest(mw_INVITE_Request_Base)}; + } + + // INVITE from IMS_A to IMS_B + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5048_01_ic(v_pcscfEutAUrl))}, + {}, + v_skip, + "TP_IMS_5048_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5080_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + // INVITE from IMS_A to IMS_B + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5080_01_ic)}, + {}, + {0, omit}, + "TP_IMS_5080_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + +} // group + +group checksTC_IMS_CALL_0013 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5072_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5072_02_gm(?))}, + {}, + {0, omit}, + "TP_IMS_5072_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + } //function + +} // group + +group checksTC_IMS_CALL_0014 { + + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5107_03_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_CANCEL_Request_Base(?))}, + {}, + {0, omit}, + "TP_IMS_5107_03", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + } //function + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5107_03_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_scscfImsAUrl := mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_A)); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5107_03_ic(?, v_scscfImsAUrl))}, + {}, + {0, omit}, + "TP_IMS_5107_03", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + } //function + +} // group + +group checksTC_IMS_CALL_0016 { + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5139_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_scscfImsAUrl := mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_A)); + var SipMessage v_sip := {request := valueof(m_INVITE_Dummy)}; + var SipUrl v_UE_URI; + var To v_to; + var From v_from; + var CallId v_callId; + var CSeq v_cSeq; + var Route v_route; + + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5139_01", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + // Get Contact Header from INVITE + + if(ischosen(v_sip.request)) { + v_from := valueof(v_sip.request.msgHeader.fromField); + v_callId := valueof(v_sip.request.msgHeader.callId); + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + {0, omit}, + "TP_IMS_5139_01", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + // Get Contact Header from 200-OK response + + if(ischosen(v_sip.response)) { + if(ispresent(v_sip.response.msgHeader.contact)) { + v_UE_URI := f_getContactAddr(v_sip.response.msgHeader.contact); + } + v_to := valueof(v_sip.response.msgHeader.toField); + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5139_01_ic(v_callId, v_UE_URI, v_to, v_from, ?, ?))}, + {}, + {0, omit}, + "TP_IMS_5139_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + } //function +} // group + +group checksTC_IMS_CALL_0024 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5135_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5135_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5135_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_ibcfEutAUrl := mw_SipUrl_Host(f_GetEUTIbcfAddress(PX_EUT_A)); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5135_01_ic(v_ibcfEutAUrl))}, + {}, + {0, omit}, + "TP_IMS_5135_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5137_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_ibcfEutAUrl := mw_SipUrl_Host(f_GetEUTIbcfAddress(PX_EUT_A)); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5137_01_ic(v_ibcfEutAUrl))}, + {}, + {0, omit}, + "TP_IMS_5137_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5404_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5404_01_gm)}, + {}, + {0, omit}, + "TP_IMS_5404_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5404_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5404_01_ic)}, + {}, + {0, omit}, + "TP_IMS_5404_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5414_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5414_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5414_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_100Trying_Base)}, + {}, + {0, omit}, + "TP_IMS_5414_01", + false, + false + ) + ); + p_monitorCompRef.done; + + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5137_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_180Ringing_Base)}, + {}, + {0, omit}, + "TP_IMS_5137_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5137_02_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5137_02_ic)}, + {}, + {0, omit}, + "TP_IMS_5137_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5137_03_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + {0, omit}, + "TP_IMS_5137_03", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5137_03_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5137_03_ic)}, + {}, + {0, omit}, + "TP_IMS_5137_03", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5408_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_ACK_Request_Base(?))}, + {}, + {0, omit}, + "TP_IMS_5408_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5408_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + var template SipUrl v_ibcfEutAUrl := mw_SipUrl_Host(f_GetEUTIbcfAddress(PX_EUT_A)); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5408_01_ic(?, v_ibcfEutAUrl))}, + {}, + {0, omit}, + "TP_IMS_5408_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5408_03_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_BYE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5408_03", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5408_03_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_ibcfEutAUrl := mw_SipUrl_Host(f_GetEUTIbcfAddress(PX_EUT_A)); + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5408_03_ic(?, v_ibcfEutAUrl))}, + {}, + {0, omit}, + "TP_IMS_5408_03", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + +} // group + +group checksTC_IMS_CALL_0025 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5408_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_CANCEL_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5408_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5408_02_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_ibcfEutAUrl := mw_SipUrl_Host(f_GetEUTIbcfAddress(PX_EUT_A)); + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5408_02_ic(?, v_ibcfEutAUrl))}, + {}, + {0, omit}, + "TP_IMS_5408_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + +} // group + +group checksTC_IMS_CALL_0026 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5408_04_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage, + integer p_skipCount + ) runs on ImsTestCoordinator { + + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {p_skipCount, mw_SipRequest(mw_INVITE_Request_Base)}; + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + v_skip, + "TP_IMS_5408_04", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5408_04_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage, + integer p_skipCount + ) runs on ImsTestCoordinator { + var template SipUrl v_ibcfEutAUrl := mw_SipUrl_Host(f_GetEUTIbcfAddress(PX_EUT_A)); + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {p_skipCount, mw_SipRequest(mw_INVITE_Request_Base)}; + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5408_04_ic(v_ibcfEutAUrl))}, + {}, + v_skip, + "TP_IMS_5408_04", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + +} // group + + +group checksTC_IMS_SS_0001 { + + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5310_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + integer p_skipCount + ) runs on ImsTestCoordinator { + + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {p_skipCount, mw_SipRequest(mw_INVITE_Request_Base)}; + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5310_01_gm)}, + {}, + v_skip, + "TP_IMS_5310_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5310_01_isc( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5310_01_isc)}, + {}, + {0, omit}, + "TP_IMS_5310_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5312_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + integer p_skipCount + ) runs on ImsTestCoordinator { + + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {p_skipCount, mw_SipResponse(mw_Response_Base(c_statusLine200, ?, ?))}; + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5312_01_ic)}, + {}, + v_skip, + "mdw_TP_IMS_5312_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5312_01_isc( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5312_01_isc)}, + {}, + {0, omit}, + "TP_IMS_5312_01", + false, + false + ) + ); + p_monitorCompRef.done; + } +} // group + + +group checksTC_IMS_SS_0002 { + + // f_mtc_check_TP_IMS_5310_01_gm already used in test TC_IMS_SS_0001 + // f_mtc_check_TP_IMS_5310_01_isc already used in test TC_IMS_SS_0001 + // f_mtc_check_TP_IMS_5312_01_ic already used in test TC_IMS_SS_0001 + // f_mtc_check_TP_IMS_5312_01_isc already used in test TC_IMS_SS_0001 +} + + +group checksTC_IMS_SS_0003 { + + // f_mtc_check_TP_IMS_5097_02_gm already used in test TC_IMS_CALL_0001 + // f_mtc_check_TP_IMS_5097_02_ic already used in test TC_IMS_CALL_0001 + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5108_03_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5108_03", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5108_03_isc( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + var template SipUrl v_AS_IMS_B := (mw_SipUrl_Host(f_GetEUTASServerAddress(PX_EUT_B)), + mw_SipUrl_Host(f_GetEUTASServerIpAddress(PX_EUT_B))); + var template SipUrl v_SCSCF_IMS_B := (mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_B)), + mw_SipUrl_Host(f_GetEUTScscfIpAddress(PX_EUT_B))); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5108_03_isc(v_AS_IMS_B, v_SCSCF_IMS_B))}, + {mw_SipRequest(mdw_TP_IMS_5108_03_f_isc)}, + {0, omit}, + "TP_IMS_5108_03", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5115_08_isc( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)},//check 200OK from ASB->IMSB + {}, + {1, mw_SipResponse(mw_200OK_Base)},//skip 200OK from IMSB->ASB + "TP_IMS_5115_08", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5115_08_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage, + integer p_skipCount + ) runs on ImsTestCoordinator { + + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {p_skipCount, mw_SipResponse(mw_Response_Base(c_statusLine200, ?, ?))}; + } + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5115_08_ic)}, + {}, + v_skip, + "TP_IMS_5115_08", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } +} + +group checksTC_IMS_SS_0004 { + + // f_mtc_check_TP_IMS_5108_03_ic already used in test TC_IMS_SS_0003 + // f_mtc_check_TP_IMS_5108_03_isc already used in test TC_IMS_SS_0003 + // f_mtc_check_TP_IMS_5115_08_ic already used in test TC_IMS_SS_0003 + // f_mtc_check_TP_IMS_5115_08_isc already used in test TC_IMS_SS_0003 +} +group checksTC_IMS_SS_0005 { + +// f_mtc_check_TP_IMS_5108_03_ic already used in test TC_IMS_SS_0003 +// f_mtc_check_TP_IMS_5108_03_isc already used in test TC_IMS_SS_0003 + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5313_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5313_01_ic)}, + {}, + {0, omit}, + "TP_IMS_5313_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5313_01_isc( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5313_01_isc)}, + {}, + {0, omit}, + "TP_IMS_5313_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } +}//end group checksTC_IMS_SS_0005 + +group checksTC_IMS_SS_0006 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_09_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5097_09", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } //function + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_09_isc( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + var template SipUrl v_AS_IMS_B := mw_SipUrl_Host(f_GetEUTASServerAddress(PX_EUT_B)); + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5097_09_isc(v_AS_IMS_B))}, + {mw_SipRequest(mdw_TP_IMS_5097_09_f_isc)}, + {0, omit}, + "TP_IMS_5097_09", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } //function + +}//end group checksTC_IMS_SS_0006 + +group checksTC_IMS_SS_0007 { + + // f_mtc_check_TP_IMS_5097_01_gm already used in test TC_IMS_CALL_0001 + // f_mtc_check_TP_IMS_5097_01_ic already used in test TC_IMS_CALL_0001 + // f_mtc_check_TP_IMS_5108_03_ic already used in test TC_IMS_SS_0003 + // f_mtc_check_TP_IMS_5108_03_isc already used in test TC_IMS_SS_0003 + // f_mtc_check_TP_IMS_5115_08_ic already used in test TC_IMS_SS_0003 + // f_mtc_check_TP_IMS_5115_08_isc already used in test TC_IMS_SS_0003 + +}//end group checksTC_IMS_SS_0007 + +group checksTC_IMS_SS_0008 { + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5046_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + {0, omit}, + "TP_IMS_5046_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5046_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_pcscfEutAUrl := mw_SipUrl_Host(f_GetEUTPcscfAddress(PX_EUT_A)); + var template SipUrl v_pcscfEutAIpUrl := mw_SipUrl_Host(f_GetEUTPcscfIpAddress(PX_EUT_A)); + var ImsUserInfo v_user := f_getAnyValidUser(PX_EUT_B); + var template SipUrl v_UserEutBUrl := mw_SipUrl_Host(v_user.domain); + var SipMessage v_sip := {request := valueof(m_INVITE_Dummy)}; + var Route v_Route; + var template Route vt_pcscfRoute := { + fieldName := ROUTE_E, + routeBody := ({mw_routeBody(v_pcscfEutAUrl), *}, + {mw_routeBody(v_pcscfEutAIpUrl), *} ) + }; + var Via v_Via; + var template Via vt_pcscfVia := { + fieldName := VIA_E, + viaBody := ({mw_ViaBody_interface(v_pcscfEutAUrl.hostPort), *}, + {mw_ViaBody_interface(v_pcscfEutAIpUrl.hostPort), *} ) + }; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest((mdw_TP_IMS_5046_01_ic(v_pcscfEutAUrl, v_UserEutBUrl), + mdw_TP_IMS_5046_01_ic(v_pcscfEutAIpUrl, v_UserEutBUrl)))}, + {mw_SipRequest(mw_INVITE_Request_Base)}, + {0, omit}, + "TP_IMS_5046_01", + true, + p_checkMessage + ) + ); + p_monitorCompRef.done; + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + if(ispresent(v_sip.request.msgHeader.route)) { + v_Route := v_sip.request.msgHeader.route; + } + //if(ispresent(v_sip.request.msgHeader.via)) { + v_Via := v_sip.request.msgHeader.via; + //} + + // Check Route header + if (match(v_Route, vt_pcscfRoute)) { + f_setIotVerdictFAIL("TP_IMS_5046_01"); + } + // Check Via header + if (match(v_Via, vt_pcscfVia)) { + } else { + f_setIotVerdictFAIL("TP_IMS_5046_01"); + } + } + + /** + * @desc Starts monitor component + */ + function f_mtc_check_TP_IMS_5110_01_isc( + ImsInterfaceMonitor p_monitorCompRef) + runs on ImsTestCoordinator + { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + {1, mw_SipResponse(mw_200OK_Base)}, + "TP_IMS_5110_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + /** + * @desc Starts monitor component + */ + function f_mtc_check_TP_IMS_5110_01_ic( + ImsInterfaceMonitor p_monitorCompRef) + runs on ImsTestCoordinator + { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + {0, omit}, + "TP_IMS_5110_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + + +} // group + +group checksTC_IMS_SS_0009 { +}//end group checksTC_IMS_SS_0009 + +group checksTC_IMS_SS_0010 { + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5308_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5308_01_gm)}, + {}, + {0, omit}, + "TP_IMS_5308_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5308_01_isc( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5308_01_isc)}, + {mw_SipResponse(mw_180Ringing_Base)}, + {0, omit}, + "TP_IMS_5308_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5308_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5308_02_gm)}, + {}, + {0, omit}, + "TP_IMS_5308_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5308_02_isc( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_TP_IMS_5308_02_isc)}, + {mw_SipResponse(mw_200OK_Base)}, + {0, omit}, + "TP_IMS_5308_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + +}//end group checksTC_IMS_SS_0010 + + group messagingChecks { + /** + * @desc Starts monitor component behavior for TP_IMS_5097_05 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_05_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5097_05", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5097_05 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_05_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var charstring v_EUT_A_Addr := f_GetEUTScscfAddress(PX_EUT_A); + + p_monitorCompRef.start( + f_imsIot_receive( + { mw_SipRequest(mdw_TP_IMS_5097_05_p_ic(*)) }, + { + mw_SipRequest(mdw_TP_IMS_5097_05_f_ic(*)), + mw_SipRequest(mdw_TP_IMS_5097_05_f2_ic(*,mw_SipUrl_Host(v_EUT_A_Addr))), + mw_SipRequest(mw_MESSAGE_Request_Base(*)) + }, + {0, omit}, + "TP_IMS_5097_05", + false, + true + ) + ); + p_monitorCompRef.done; + + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5097_05_p_ic(*))}, + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {0, omit}, + "TP_IMS_5097_05", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5097_05 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_07_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5097_07", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5097_07 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_07_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5097_07_ic(*,mw_SIP_URI_Base, mw_TEL_URI_Base))}, + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {0, omit}, + "TP_IMS_5097_07", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5097_08 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_08_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5097_08_gm(*))}, + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {0, omit}, + "TP_IMS_5097_08", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5097_08 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5097_08_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5097_08_ic(*))}, + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {0, omit}, + "TP_IMS_5097_08", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5117_02 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5117_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_2XX_Base)}, + {}, + {0, omit}, + "TP_IMS_5117_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5117_02 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5117_02_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_TP_IMS_5117_02_ic)}, + {mw_SipResponse(mdw_2XX_Base)}, + {0, omit}, + "TP_IMS_5117_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + + /** + * @desc Starts monitor component behavior for TP_IMS_5117_06 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5117_06_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_2XX_Base)}, + {}, + {0, omit}, + "TP_IMS_5117_06", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5117_06 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5117_06_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_TP_IMS_5117_06_ic)}, + {mw_SipResponse(mdw_2XX_Base)}, + {0, omit}, + "TP_IMS_5117_06", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5118_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5118_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_200OK_Base)}, + {}, + {0, omit}, + "TP_IMS_5118_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5118_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5118_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_TP_IMS_5118_01_ic)}, + {mw_SipResponse(mw_200OK_Base)}, + {0, omit}, + "TP_IMS_5118_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5108_02 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5108_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5108_02", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5108_02 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5108_02_ic( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + var template SipUrl v_SCSCF_IMS_B := mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_B)); + var SemicolonParam_List p_paramList; + var GenericParam p_param; + var SipMessage v_sip := {request := valueof(m_INVITE_Dummy)}; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5108_02a_ic(*))}, + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {0, omit}, + "TP_IMS_5108_02", + true, + true + ) + ); + p_monitorCompRef.done; + + f_getSipMsgFromMonitor(p_monitorCompRef, v_sip); + p_paramList := v_sip.request.msgHeader.pChargingVector.chargeParams; + for(var integer i := 0; i < lengthof(p_paramList); i:= i+1) { + if(p_paramList[i].id == "icid-value") { + p_param := p_paramList[i]; + } + } + + p_monitorCompRef.start( + f_imsIot_receive( + {}, + { + mw_SipRequest(mdw_TP_IMS_5108_02b_f_ic(*)), + mw_SipRequest(mw_MESSAGE_Request_Base(*)) + }, + {0, omit}, + "TP_IMS_5108_02", + false, + true + ) + ); + p_monitorCompRef.done; + + + p_monitorCompRef.start( + f_imsIot_receive( + {}, + { + mw_SipRequest(mdw_TP_IMS_5108_02b_p_ic(*, v_SCSCF_IMS_B, p_param)), + mw_SipRequest(mw_MESSAGE_Request_Base(*)) + }, + {0, omit}, + "TP_IMS_5108_02", + false, + false + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5050_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5050_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5050_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5050_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5050_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + boolean p_checkMessage + ) runs on ImsTestCoordinator { + var template SipUrl v_PCSCF_IMS_B := mw_SipUrl_Host(f_GetEUTPcscfAddress(PX_EUT_B)); + var template SipUrl v_UE_A := mw_SipUrl_Host(f_GetEUTPublicId(PX_EUT_A)); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5050_01_ic(*, v_PCSCF_IMS_B, v_UE_A))}, + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {0, omit}, + "TP_IMS_5050_01", + false, + p_checkMessage + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5050_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5114_02_gm( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5114_02", + false, + false + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5050_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5114_02_ic( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5114_02", + false, + false + ) + ); + p_monitorCompRef.done; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_4XX_Base)}, + {}, + {0, omit}, + "TP_IMS_5114_02", + false, + false + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5108_06 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5108_06_gm( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5108_06", + false, + false + ) + ); + p_monitorCompRef.done; + } + + /** + * @desc Starts monitor component behavior for TP_IMS_5108_06 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5108_06_ic( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_MESSAGE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5108_06", + false, + false + ) + ); + p_monitorCompRef.done; + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_404NotFound_Base)}, + {}, + {0, omit}, + "TP_IMS_5108_06", + false, + false + ) + ); + p_monitorCompRef.done; + } + } + + group callChecks { + + + /** + * @desc Starts monitor component behavior for TP_IMS_5106_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5106_01_gm( + ImsInterfaceMonitor p_monitorCompRef, + integer p_skipCount + ) runs on ImsTestCoordinator { + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {1, mw_SipRequest(mw_INVITE_Request_Base)}; + } + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_INVITE_Request_Base)}, + {}, + v_skip, + "TP_IMS_5106_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5106_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5106_01_ic( + ImsInterfaceMonitor p_monitorCompRef, + integer p_skipCount + ) runs on ImsTestCoordinator { + var template SipUrl v_SCSCF_A_Uri := (mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_A)), + mw_SipUrl_Host(f_GetEUTScscfIpAddress(PX_EUT_A))); + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {1, mw_SipRequest(mw_INVITE_Request_Base)}; + } + + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5106_01_ic(v_SCSCF_A_Uri))}, + {mw_SipRequest(mw_INVITE_Request_Base)}, + v_skip, + "TP_IMS_5106_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5106_02 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5106_02_gm( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mw_UPDATE_Request_Base(*))}, + {}, + {0, omit}, + "TP_IMS_5106_02", + false, + false + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5106_02 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5106_02_ic( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + var template SipUrl v_SCSCF_A_Uri := mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_A)); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5106_02_p_ic(*,v_SCSCF_A_Uri))}, + { + mw_SipRequest(mdw_TP_IMS_5106_02_f_ic(*,v_SCSCF_A_Uri)), + mw_SipRequest(mw_UPDATE_Request_Base(*))}, + {0, omit}, + "TP_IMS_5106_02", + false, + false + ) + ); + p_monitorCompRef.done; + } + + + + /** + * @desc Starts monitor component behavior for TP_IMS_5121_02 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5121_02_gm( + ImsInterfaceMonitor p_monitorCompRef, + integer p_skipCount + ) runs on ImsTestCoordinator { + // TODO TP must be checked, currently only 2XX is checked + + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {1, mw_SipResponse(mdw_2XX_Base)}; + } + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mdw_2XX_Base)}, + {}, + v_skip, + "TP_IMS_5121_02", + false, + false + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5121_02 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5121_02_ic( + ImsInterfaceMonitor p_monitorCompRef, + integer p_skipCount + ) runs on ImsTestCoordinator { + var template SipUrl v_SCSCF_A_Uri := mw_SipUrl_Host(f_GetEUTScscfAddress(PX_EUT_A)); + var template SkipType v_skip := {0, omit}; + + if(p_skipCount > 0) { + v_skip := {1, mw_SipResponse(mdw_2XX_Base)}; + } + + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipResponse(mw_TP_IMS_5121_02_ic)}, + {mw_SipResponse(mdw_2XX_Base)}, + v_skip, + "TP_IMS_5121_02", + false, + false + ) + ); + p_monitorCompRef.done; + } + + + /** + * @desc Starts monitor component behavior for TP_IMS_5074_01 + * @param p_monitorCompRef Reference to monitor component + */ + function f_mtc_check_TP_IMS_5074_01_ic( + ImsInterfaceMonitor p_monitorCompRef + ) runs on ImsTestCoordinator { + var template SipUrl v_UE_A_Uri := f_getUeIpAddress(PX_EUT_A); + + p_monitorCompRef.start( + f_imsIot_receive( + {mw_SipRequest(mdw_TP_IMS_5074_01_ic(*,v_UE_A_Uri))}, + {mw_SipRequest(mw_BYE_Request_Base(*))}, + {0, omit}, + "TP_IMS_5074_01", + false, + false + ) + ); + p_monitorCompRef.done; + } + } + +} // end group +}// end module Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_Functions.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_Functions.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_Functions.ttcn (revision 18) @@ -0,0 +1,1556 @@ +/** + * @author STF 370 + * @version $Id: $ + * @desc This module provides common function for TestCoordinator component. + */ +module AtsImsIot_Functions { + + import from AtsImsIot_Templates {template mw_SIP_URI_Base;} + + import from LibSip_SIPTypesAndValues all; + + import from AtsImsIot_TestSystem { + type ImsTestCoordinator, ImsInterfaceMonitor; + } + + import from LibIot_PIXITS {modulepar PX_MAX_MSG_WAIT, PX_PRODUCTS, PX_AVAILABLE_INTERFACES;} + import from LibIot_Functions { + function f_setConformanceVerdict; + } + + import from AtsImsIot_TypesAndValues { + type SipMessage, SipMessageList, SkipType; + } + + import from LibIms_UpperTester all; + + import from LibIot_TestInterface { + type InterfaceMonitor, TestCoordinator, EquipmentUser; + } + + import from LibIot_Functions {function f_getE2EVerdict;} + + import from LibIot_TypesAndValues {type DefaultList;} + + group ue { + + /** + * @desc + * Starts user component behavior for triggering the registration + * procedures at the UE from test coordinator. + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userRegistration(EquipmentUser p_userCompRef, ImsUserInfo p_userInfo) + runs on TestCoordinator + return boolean { + var boolean v_status := true; + // TODO Investigate if f_PR_user_home_registration is to be removed + // Reason: Thre is no difference when triggering UE to register in home or visiting NW + if( p_userInfo.publicId == "dummy" ) { return false; } + + v_status := f_mtc_userRegister(p_userCompRef, p_userInfo.publicId, p_userInfo.privateId, p_userInfo.password); + return v_status; + } + + /** + * @desc + * Starts user component behavior for checking the successful + * registration. + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userCheckRegistration(EquipmentUser p_userCompRef, ImsUserInfo p_userInfo) + runs on TestCoordinator return boolean { + var boolean v_status := true; + if( p_userInfo.publicId == "dummy" ) { return false; } + v_status := f_mtc_userCheckRegistrationSuccessful(p_userCompRef); + return v_status; + } + + /** + * @desc + * Starts user component behavior for checking that UE + * is not registerd. + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + **/ + function f_mtc_userCheckNoRegistration(EquipmentUser p_userCompRef, ImsUserInfo p_userInfo) + runs on TestCoordinator return boolean { + var boolean v_status := true; + if( p_userInfo.publicId == "dummy" ) { return true; } + v_status := f_mtc_userCheckRegistrationUnsuccessful(p_userCompRef); + return v_status; + } + + /** + * @desc Trigger UE given by p_ueRef to initiate an MO call + * @param p_ueRef Reference to IMS UE user component + * @param p_calledParty ImsUserInfo of called party + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userInitiateCall(EquipmentUser p_ueRef, ImsUserInfo p_calledParty) + runs on TestCoordinator return boolean { + var boolean v_status := true; + if( p_calledParty.publicId == "dummy" ) { return true; } + v_status := f_mtc_userInitiateCallSuccessful(p_ueRef); + return v_status; + } + + /** + * + * @desc Starts user component behaviour for checking that the User + * Call has been initiated + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userInitiateCallSuccessful(EquipmentUser p_userCompRef) + runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_checkUserCallIsInitiated()); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + return v_success; + } + + /** + * @desc Answer call + * @param p_ueRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userAnswerCall(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + v_status := f_mtc_userAnswerCallSuccessful(p_ueRef); + return v_status; + } + + /** + * + * @desc Starts user component behaviour for checking that the User + * Call has been answered + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userAnswerCallSuccessful(EquipmentUser p_userCompRef) + runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_checkUserCallIsAnswered()); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + return v_success; + } + + /** + * @desc End the call + * @param p_ueRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_EndCall(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + v_status := f_mtc_userEndCallSuccessful(p_ueRef); + return v_status; + } + + /** + * + * @desc Starts user component behaviour for checking that the User + * Call has been ended + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userEndCallSuccessful(EquipmentUser p_userCompRef) + runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_checkUserCallIsEnded()); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + return v_success; + } + + /** + * @desc Trigger UE given by p_ueRef to add a new media stream + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userAddNewMediaStream(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + v_status := f_mtc_userAddNewMediaStreamSuccessful(p_ueRef); + return v_status; + } + + /** + * + * @desc Starts user component behaviour for checking that + * a new media stream has been added + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userAddNewMediaStreamSuccessful(EquipmentUser p_userCompRef) + runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_checkUserAddNewMediaStream()); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + return v_success; + } + + /** + * @desc Trigger UE given by p_ueRef to remove a media stream + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userRemoveMediaStream(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + v_status := f_mtc_userRemoveNewMediaStreamSuccessful(p_ueRef); + return v_status; + } + + /** + * + * @desc Starts user component behaviour for checking that + * a new media stream has been added + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userRemoveNewMediaStreamSuccessful(EquipmentUser p_userCompRef) + runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_checkUserRemoveNewMediaStream()); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + return v_success; + } + + + /** + * @desc Trigger UE given by p_ueRef to check the remove of a media stream + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userCheckRemoveMediaStream(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + /** + * @desc Trigger UE given by p_ueRef to add a new media stream + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userModifiyMediaStream(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + /** + * @desc Trigger UE given by p_ueRef to add a new media stream + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userCheckNewMediaStream(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + + /** + * @desc Trigger UE given by p_ueRef to loose conectifity + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userLooseConnection(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + /** + * @desc Trigger UE given by p_ueRef to enter CANCEL current call + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userTriggerCancelCall(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + /** + * @desc Trigger UE given by p_ueRef to enter HOLD state + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userTriggerHold(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + /** + * @desc Trigger UE given by p_ueRef to leave HOLD state and resume pending call + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userTriggerResume(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + /** + * @desc Check that UE given by p_ueRef is ringing + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckRinging(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + /** + * @desc Check that UE given by p_ueRef reports a successfull call establishment + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckCallEstablished(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + /** + * @desc Check that UE given by p_ueRef reports a not successfull call establishment + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckCallCannotBeEstablished(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + + /** + * @desc Check that UE by p_ueRef given reports that its peer is ringing + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckPeerIsRinging(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + /** + * @desc Check that UE by p_ueRef given reports HOLD state + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckUserOnHold(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + /** + * @desc Check that UE by p_ueRef given reports that call has been resumed + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckCallResumed(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + /** + * @desc Check that UE by p_ueRef given reports that call has ended + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckCallEnded(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + /** + * @desc Check that UE by p_ueRef given reports that call is terminated + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckCallTerminated(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + /** + * @desc Check that UE by p_ueRef given reports that call is no longer offered + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckCallNoLongerOffered(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + /** + * @desc Check that UE by p_ueRef given reports that call has been cancelled + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckCallCancelled(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + /** + * @desc Check that UE by p_ueRef given reports that call has been rejected due to ACR + * @param p_userCompRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_userCheckCallRejectedACR(EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + /** + * @desc Start capturing and monitoring traffic on all configured interfaces + * @return true or false + */ + function f_mtc_StartAllTrafficCapture() + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + + + /** + * @desc Starts user component behaviour for registration from test coordinator + * @param p_userCompRef Reference to IMS UE user component + * @param p_publicId public user identity + * @param p_privateId private user identity + * @param p_pw user password + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userRegister(EquipmentUser p_userCompRef, charstring p_publicId, charstring p_privateId, charstring p_pw) runs on TestCoordinator return boolean { + // TODO server address parameter may needed + var boolean v_success := false; + + p_userCompRef.start(f_userRegistration(p_publicId, p_privateId, p_pw)); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + + return v_success; + } + + function f_mtc_userCheckRegistrationSuccessful(EquipmentUser p_userCompRef) runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_checkUserIsRegistered()); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + + return v_success; + } + /** + * + * @desc Starts user component behaviour for checking that the UE + * is not registered + * @param p_userCompRef Reference to IMS UE user component + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userCheckRegistrationUnsuccessful(EquipmentUser p_userCompRef) + runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_checkUserIsNotRegistered()); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + return v_success; + } + + /** + * @desc Starts user component behaviour for registration from test coordinator + * @param p_userCompRef Reference ot IMS UE user component + * @param publicId public user identity + * @return + * true in case of successfull execution of the trigger command + * otherwise false + */ + function f_mtc_userDeregister(EquipmentUser p_userCompRef, charstring p_publicId) runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_userDeregistration(p_publicId)); + + p_userCompRef.done; + + if( f_getE2EVerdict() == pass) { + v_success := true; + } + + return v_success; + } + + /** + * + * @desc Starts user component behaviour for sending a message from test coordinator + * @param p_userCompRef Reference ot IMS UE user component + * @param p_content Content of meessage to be sent + */ + function f_mtc_userSendMessage(EquipmentUser p_userCompRef, charstring p_content) runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_userSendMessage(p_content)); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + + return v_success; + } + + /** + * + * @desc Starts user component behaviour for checking message receipt from test coordinator + * @param p_userCompRef Reference ot IMS UE user component + * @param p_content Content of meessage to be received + */ + function f_mtc_userCheckMessageReceipt(EquipmentUser p_userCompRef) runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_userCheckMessageReceipt()); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + + return v_success; + } + + /** + * + * @desc Starts user component behaviour for checking message receipt from test coordinator + * @param p_userCompRef Reference ot IMS UE user component + * @param p_content Content of meessage to be received + */ + function f_mtc_userCheckMessageNotDelivered(EquipmentUser p_userCompRef) runs on TestCoordinator return boolean { + var boolean v_success := false; + + p_userCompRef.start(f_userCheckMessageNotDelivered()); + + p_userCompRef.done; + + if(f_getE2EVerdict() == pass) { + v_success := true; + } + + return v_success; + } + + + /** + * @desc Trigger IMS Network to deregister UE given by p_ueRef + * @param p_imsRef Reference to IMS network component + * @param p_ueRef Reference to IMS UE user component + * @return true or false + */ + function f_mtc_imsTriggerUeDeregistration(EquipmentUser p_imsRef, EquipmentUser p_ueRef) + runs on TestCoordinator return boolean { + var boolean v_status := true; + // TODO + return v_status; + } + + + + + + /* + * + * @desc Looks for genUser (any) of a specific product + * @param p_productIdx Index of the product + * @return genUser + */ + function f_getAnyValidUser(integer p_productIdx) return ImsUserInfo { + var integer v_size := sizeof(PX_IMS_USER_DATA); + const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" }; + var ImsUserIdentity v_userid; + + for(var integer i := 0; i < v_size; i := i+1) { + if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) { + var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds); + for(var integer j := 0; j < v_size_j; j := j+1) { + if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].genUserId )) { + return PX_IMS_USER_DATA[i].userIds[j].genUserId; + } // end if + } // end for j + log("f_getAnyValidUser: Did not find specified user id in specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } // end if + } // end for i + log("f_getAnyValidUser: Did not find specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } + + /* + * + * @desc Looks for TelUser of a specific product + * @param p_productIdx Index of the product + * @return TelUser + */ + function f_getTelUserId(integer p_productIdx) return ImsUserInfo { + var integer v_size := sizeof(PX_IMS_USER_DATA); + const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" }; + var ImsUserIdentity v_userid; + + for(var integer i := 0; i < v_size; i := i+1) { + if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) { + var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds); + for(var integer j := 0; j < v_size_j; j := j+1) { + if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].telUserId )) { + return PX_IMS_USER_DATA[i].userIds[j].telUserId; + } // end if + } // end for j + log("f_getTelUserId: Did not find specified user id in specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } // end if + } // end for i + log("f_getTelUserId: Did not find specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } + + /* + * + * @desc Looks for SipUser of a specific product + * @param p_productIdx Index of the product + * @return SipUser + */ + function f_getSipUserId(integer p_productIdx) return ImsUserInfo { + var integer v_size := sizeof(PX_IMS_USER_DATA); + const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" }; + var ImsUserIdentity v_userid; + + for(var integer i := 0; i < v_size; i := i+1) { + if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) { + var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds); + for(var integer j := 0; j < v_size_j; j := j+1) { + if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].sipUserId )) { + return PX_IMS_USER_DATA[i].userIds[j].sipUserId; + } // end if + } // end for j + log("f_getSipUserId: Did not find specified user id in specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } // end if + } // end for i + log("f_getSipUserId: Did not find specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } + + /* + * + * @desc Looks for ARCUser for a specific product + * @param p_productIdx Index of the product + * @return ARCUser + */ + function f_getACRUser(integer p_productIdx) return ImsUserInfo { + var integer v_size := sizeof(PX_IMS_USER_DATA); + const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" }; + var ImsUserIdentity v_userid; + + for(var integer i := 0; i < v_size; i := i+1) { + if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) { + var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds); + for(var integer j := 0; j < v_size_j; j := j+1) { + if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].acrUserId )) { + return PX_IMS_USER_DATA[i].userIds[j].acrUserId; + } // end if + } // end for j + log("f_getACRUser: Did not find specified user id in specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } // end if + } // end for i + log("f_getACRUser: Did not find specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } + + /* + * + * @desc Looks for OIPUser for a specific product + * @param p_productIdx Index of the product + * @return OIPUser + */ + function f_getOIPUser(integer p_productIdx) return ImsUserInfo { + var integer v_size := sizeof(PX_IMS_USER_DATA); + const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" }; + var ImsUserIdentity v_userid; + + for(var integer i := 0; i < v_size; i := i+1) { + if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) { + var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds); + for(var integer j := 0; j < v_size_j; j := j+1) { + if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].oipUserId )) { + return PX_IMS_USER_DATA[i].userIds[j].oipUserId; + } // end if + } // end for j + log("f_getOIPUser: Did not find specified user id in specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } // end if + } // end for i + log("f_getOIPUser: Did not find specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } + + /* + * + * @desc Looks for OIRUser for a specific product + * @param p_productIdx Index of the product + * @return OIRUser + */ + function f_getOIRUser(integer p_productIdx) return ImsUserInfo { + var integer v_size := sizeof(PX_IMS_USER_DATA); + const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" }; + var ImsUserIdentity v_userid; + + for(var integer i := 0; i < v_size; i := i+1) { + if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) { + var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds); + for(var integer j := 0; j < v_size_j; j := j+1) { + if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].oirUserId )) { + return PX_IMS_USER_DATA[i].userIds[j].oirUserId; + } // end if + } // end for j + log("f_getOIRUser: Did not find specified user id in specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } // end if + } // end for i + log("f_getOIRUser: Did not find specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } + + /* + * + * @desc Looks for HoldUser for a specific product + * @param p_productIdx Index of the product + * @return HoldUser + */ + function f_getHoldUser(integer p_productIdx) return ImsUserInfo { + var integer v_size := sizeof(PX_IMS_USER_DATA); + const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" }; + var ImsUserIdentity v_userid; + + for(var integer i := 0; i < v_size; i := i+1) { + if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) { + var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds); + for(var integer j := 0; j < v_size_j; j := j+1) { + if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].holdUserId )) { + return PX_IMS_USER_DATA[i].userIds[j].holdUserId; + } // end if + } // end for j + log("f_getHoldUser: Did not find specified user id in specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } // end if + } // end for i + log("f_getHoldUser: Did not find specified product in PX_IMS_USER_DATA"); + return c_dummyInfo; + } + + // TODO + function f_getUEHostname(integer p_ID, out charstring p_hostname) + return boolean { + + // TODO + + return true; + } + + /** + * @desc + * Preamble to handle user registration in home network from test coordinator + * @param p_userCompRef Reference ot IMS UE user component + * @return true in case of successfull execution otherwise false + */ + function f_PR_user_home_registration(EquipmentUser p_userCompRef, ImsUserInfo p_userInfo) + runs on TestCoordinator return boolean { + var boolean v_status := true; + if( p_userInfo.publicId == "" ) { return false; } + + v_status := f_mtc_userRegister(p_userCompRef, p_userInfo.publicId, p_userInfo.privateId, p_userInfo.password); + + return v_status; + } + + /** + * @desc + * Postamble to handle user deregistration in home network from test coordinator + * @param p_userCompRef Reference ot IMS UE user component + * @return true in case of successfull execution otherwise false + */ + function f_PO_user_home_deregistration(EquipmentUser p_userCompRef) runs on ImsTestCoordinator return boolean { + var boolean v_status := true; + + v_status := f_mtc_userDeregister(p_userCompRef, "*"); // deregister all previous users + + return v_status; + } + + /** + * @desc + * Preamble to handle user registration in roaming network from test coordinator + * @param p_userCompRef Reference ot IMS UE user component + * @return true in case of successfull execution otherwise false + */ + function f_PR_user_roaming_registration(EquipmentUser p_userCompRef, ImsUserInfo p_userInfo) + runs on TestCoordinator return boolean { + var boolean v_status := true; + if( p_userInfo.publicId == "" ) { return false; } + + // TODO check roaming registration + v_status := f_mtc_userRegister(p_userCompRef, p_userInfo.publicId, p_userInfo.privateId, p_userInfo.password); + + return v_status; + } + + /** + * @desc + * Postamble to handle user deregistration in roaming network from test coordinator + * @param p_userCompRef Reference ot IMS UE user component + * @return true in case of successfull execution otherwise false + */ + function f_PO_user_roaming_deregistration(EquipmentUser p_userCompRef) runs on ImsTestCoordinator return boolean { + var boolean v_status := true; + + // TODO check roaming de-registration + v_status := f_mtc_userDeregister(p_userCompRef, "*"); // deregister all previous users + + return v_status; + } + + /** + * @desc Get the S-CSCF FQDN address of referenced EUT + * @return if a S-CSCF is avaiable, the domainname of the S-CSCF, + * otherwise error_string + */ + function f_GetEUTScscfAddress(integer p_ProductIdx) return charstring { + var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces); + var integer v_size_ipinterfaceinfo; + var integer v_interface := -1; + var integer v_ipinterfaceinfo := -1; + var charstring v_domainname; + + for(var integer i := 0; i < v_size_interfaces; i := i+1) { + if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Mm][Ww]")){ + v_interface := i; + break; + } + } + if (v_interface > -1) { + v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo); + for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) { + if(ispresent(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName)) { + v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName; + if (match(substr(v_domainname, 0, 5), pattern "[Ss][Cc][Ss][Cc][Ff]") + or match(substr(v_domainname, 0, 5), pattern "[Ss][Tt][Ee][Cc][Hh]")) { + v_ipinterfaceinfo := i; + break; + } + } + } + } else { + log ("S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + if (v_ipinterfaceinfo > -1) { + return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].domainName; + } else { + log ("S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + } + + /** + * @desc Get the S-CSCF FQDN address of referenced EUT + * @return if a S-CSCF is avaiable, the IP Address of the S-CSCF, + * otherwise error_string + */ + function f_GetEUTScscfIpAddress(integer p_ProductIdx) return charstring { + var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces); + var integer v_size_ipinterfaceinfo; + var integer v_interface := -1; + var integer v_ipinterfaceinfo := -1; + var charstring v_domainname; + + for(var integer i := 0; i < v_size_interfaces; i := i+1) { + if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Mm][Ww]")){ + v_interface := i; + } + } + if (v_interface > -1) { + v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo); + for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) { + if(ispresent(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName)) { + v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName; + if (match(substr(v_domainname, 0, 5), pattern "[Ss][Cc][Ss][Cc][Ff]") + or match(substr(v_domainname, 0, 5), pattern "[Ss][Tt][Ee][Cc][Hh]")) { + v_ipinterfaceinfo := i; + } + } + } + } else { + log ("S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + if (v_ipinterfaceinfo > -1) { + return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].IpAddress; + } else { + log ("S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + } + + /** + * @desc Get the P-CSCF FQDN address of referenced EUT + * @return if a PCSCF is avaiable, the domainname of the PCSCF, + * otherwise error_string + */ + function f_GetEUTPcscfAddress(integer p_ProductIdx) return charstring { + var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces); + var integer v_size_ipinterfaceinfo; + var integer v_interface := -1; + var integer v_ipinterfaceinfo := -1; + var charstring v_domainname; + + for(var integer i := 0; i < v_size_interfaces; i := i+1) { + if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Gg][Mm]")){ + v_interface := i; + break; + } + } + if (v_interface > -1) { + v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo); + for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) { + if(ispresent(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName)) { + v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName; + if (match(substr(v_domainname, 0, 5), pattern "[Pp][Cc][Ss][Cc][Ff]") + or match(substr(v_domainname, 0, 5), pattern "[Pp][Tt][Ee][Cc][Hh]")) { + v_ipinterfaceinfo := i; + } + } + } + } else { + log ("P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + if (v_ipinterfaceinfo > -1) { + return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].domainName; + } else { + log ("P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + } + + /** + * @desc Get the P-CSCF IP address of referenced EUT + * @return if a PCSCF is avaiable, the IP address of the PCSCF, + * otherwise error_string + */ + function f_GetEUTPcscfIpAddress(integer p_ProductIdx) return charstring { + var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces); + var integer v_size_ipinterfaceinfo; + var integer v_interface := -1; + var integer v_ipinterfaceinfo := -1; + var charstring v_domainname; + + for(var integer i := 0; i < v_size_interfaces; i := i+1) { + if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Gg][Mm]")){ + v_interface := i; + break; + } + } + if (v_interface > -1) { + v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo); + for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) { + if(ispresent(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName)) { + v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName; + if (match(substr(v_domainname, 0, 5), pattern "[Pp][Cc][Ss][Cc][Ff]") + or match(substr(v_domainname, 0, 5), pattern "[Pp][Tt][Ee][Cc][Hh]")) { + v_ipinterfaceinfo := i; + } + } + } + } else { + log ("P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + if (v_ipinterfaceinfo > -1) { + return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].IpAddress; + } else { + log ("P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + } + + /** + * @desc Get the IBCF FQDN address of referenced EUT + * @return if a IBCF is avaiable, the domainname of the IBCF, + * otherwise error_string + */ + function f_GetEUTIbcfAddress(integer p_ProductIdx) return charstring { + var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces); + var integer v_size_ipinterfaceinfo; + var integer v_interface := -1; + var integer v_ipinterfaceinfo := -1; + var charstring v_domainname; + + for(var integer i := 0; i < v_size_interfaces; i := i+1) { + if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Mm][Ww]")){ + v_interface := i; + } + } + if (v_interface > -1) { + v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo); + for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) { + if(ispresent(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName)) { + v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName; + if (match(substr(v_domainname, 0, 5), pattern "[Ii][Bb][Cc][Ff]")) { + v_ipinterfaceinfo := i; + } + } + } + } else { + log ("IBCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "IBCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + if (v_ipinterfaceinfo > -1) { + return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].domainName; + } else { + log ("IBCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "IBCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + } + + /** + * @desc Get the Public Id of referenced UE + * @param p_ProductIdx index of the product the UE belongs to + * @return PublicID of the UE of the productIdx + */ + function f_GetUEPublicId(integer p_ProductIdx) return charstring { + + var ImsUserInfo v_uePublicId := f_getSipUserId(p_ProductIdx); + + return v_uePublicId.publicId; + } + + + /** + * @desc Get the UE URI containing the IP address of referenced EUT + */ + function f_getUeIpAddress(integer p_ProductIdx) return template SipUrl { + // TODO + return mw_SIP_URI_Base; + } + + /** + * @desc Get the Public Id of referenced EUT + */ + function f_GetEUTPublicId(integer p_ProductIdx) return charstring { + // TODO + return "TODO"; + } + + /** + * @desc Get the AS server FQDN of referenced EUT + */ + function f_GetEUTASServerAddress(integer p_ProductIdx) return charstring { + var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces); + var integer v_size_ipinterfaceinfo; + var integer v_interface := -1; + var integer v_ipinterfaceinfo := -1; + var charstring v_domainname; + + for(var integer i := 0; i < v_size_interfaces; i := i+1) { + if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Ii][Ss][Cc]")){ + v_interface := i; + } + } + if (v_interface > -1) { + v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo); + for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) { + v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName; + if (match(substr(v_domainname, 0, 2), pattern "[Aa][Ss]") + or match(substr(v_domainname, 2, 2), pattern "[Aa][Ss]") + or match(substr(v_domainname, 9, 2), pattern "[Aa][Ss]")) { + v_ipinterfaceinfo := i; + } + } + } else { + log ("AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + if (v_ipinterfaceinfo > -1) { + return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].domainName; + } else { + log ("AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + } + + } + + /** + * @desc Get the AS server IP Address of referenced EUT + */ + function f_GetEUTASServerIpAddress(integer p_ProductIdx) return charstring { + var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces); + var integer v_size_ipinterfaceinfo; + var integer v_interface := -1; + var integer v_ipinterfaceinfo := -1; + var charstring v_domainname; + + for(var integer i := 0; i < v_size_interfaces; i := i+1) { + if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Ii][Ss][Cc]")){ + v_interface := i; + } + } + if (v_interface > -1) { + v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo); + for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) { + v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName; + if (match(substr(v_domainname, 0, 2), pattern "[Aa][Ss]") + or match(substr(v_domainname, 2, 2), pattern "[Aa][Ss]") + or (lengthof(v_domainname) >= 11 and match(substr(v_domainname, 9, 2), pattern "[Aa][Ss]"))) { + v_ipinterfaceinfo := i; + } + } + } else { + log ("AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + if (v_ipinterfaceinfo > -1) { + return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].IpAddress; + } else { + log ("AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."); + return "AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found."; + } + } + + + group interComponent { + /** + * @desc + * This function waits for a sip message send from a given monitor + * component to mtc. + * @param p_monitor Reference of Interface Monitor component + * @param p_msg The Sip message + */ + function f_getSipMsgFromMonitor(InterfaceMonitor p_monitor, out SipMessage p_msg) runs on ImsTestCoordinator { + timer t_local := PX_MAX_MSG_WAIT; + t_local.start; + alt { + []icpPort.receive (SipMessage:?) /*from p_monitor*/ -> value p_msg { + t_local.stop; + setverdict(pass, self, "***f_getMsgFromMonitor: SIP message received***"); + } + []t_local.timeout { + setverdict(fail, self, "***f_getMsgFromMonitor: SIP message not received***"); + } + } + } + } + + group altsteps { + + altstep a_default(in charstring p_TP) runs on ImsInterfaceMonitor { + [] dPort.receive(Request:?) { + log(self, "### a_default: Request default for " & p_TP ); + repeat; + } + [] dPort.receive(Response:?) { + log(self, "### a_default: Response default for " & p_TP ); + repeat; + } + [] dPort.receive { + log(self, "*** a_default: Received/ignored unexpected message when waiting for message complying to " & p_TP ); + //setverdict(fail, self, "### YANN: If execution is here, this means that the message was not properly decoded due to sip/sdp-codets exception, check MMagic logs"); + //stop; // YANN: If execution is here, this means that the message was not properly decoded + repeat; + } + } + + /** + * @desc This altstep add one alternative checking for a very specifc SIP request. + If it matches then the conformance verdict is set to requested verdict + * @param p_message The expected SIP request + * @param p_verdict Verdict to be used in case of match + * @param p_tpId The test purpose identifier + * * @param p_forwardMtc indicates if the received request should be forwarded to mtc + */ + altstep a_receive_sipRequest( + in template Request p_message, + in verdicttype p_verdict, + in charstring p_tpId, + in boolean p_forwardMtc, + in boolean p_checkMessage + ) runs on ImsInterfaceMonitor { + var Request v_message; + [not p_checkMessage] dPort.receive(p_message) -> value v_message { + f_setConformanceVerdict(p_verdict, "***a_receive_sipRequest: Received expected SIP request complying to " & p_tpId & " on interface " & vc_interfaceName & " ***"); + if(p_forwardMtc) { + var SipMessage v_msg; + v_msg.request := v_message; + log("### Forwarding message to MTC"); + icpPort.send(v_msg); + } + } + [p_checkMessage] dPort.check(receive(p_message) -> value v_message) { + f_setConformanceVerdict(p_verdict, "***a_receive_sipRequest: Checked expected SIP request complying to " & p_tpId & " on interface " & vc_interfaceName & " ***"); + if(p_forwardMtc) { + var SipMessage v_msg; + v_msg.request := v_message; + log("### Forwarding message to MTC"); + icpPort.send(v_msg); + } + } + } + + /** + * @desc This altstep add one alternative checking for a very specifc SIP response. + If it matches then the conformance verdict is set to requested verdict + * @param p_message The expected SIP response + * @param p_verdict Verdict to be used in case of match + * @param p_tpId The test purpose identifier + * @param p_forwardMtc indicates if the received reponse should be forwarded to mtc + */ + altstep a_receive_sipResponse( + in template Response p_message, + in verdicttype p_verdict, + in charstring p_tpId, + in boolean p_forwardMtc, + in boolean p_checkMessage + ) runs on ImsInterfaceMonitor { + var Response v_message; + [not p_checkMessage] dPort.receive(p_message) -> value v_message { + f_setConformanceVerdict(p_verdict, "***a_receive_sipResponse: Received expected SIP request complying to " & p_tpId & " on interface " & vc_interfaceName & " ***"); + if(p_forwardMtc) { + var SipMessage v_msg; + v_msg.response := v_message; + icpPort.send(v_msg); + } + } + [p_checkMessage] dPort.check(receive(p_message) -> value v_message) { + f_setConformanceVerdict(p_verdict, "***a_receive_sipResponse: Checked expected SIP request complying to " & p_tpId & " on interface " & vc_interfaceName & " ***"); + if(p_forwardMtc) { + var SipMessage v_msg; + v_msg.response := v_message; + icpPort.send(v_msg); + } + } + } + + }// end group + + function f_setInterfaceNameOnComponent(charstring p_name) runs on ImsInterfaceMonitor{ + vc_interfaceName := p_name; + } + + group general_td_functions { + + /** + * @desc + * Generic function for reading and verifying messages on the + * interface associated to the ImsInterfaceMonitor instance. This + * functions works as follows: First, messages are skipped according + * to the p_skip template. The p_skip template contains a message + * template and a counter indicating the number of received messages + * matching the message template to be skipped. If not enough + * messages matching the message template arrive at the interface, + * the function fails after timout. Next, messages are consumed from + * the interface and matched against the p_passCriteria template + * list and the p_failCriteria template list. The function + * terminates with pass if a message is received matching a + * pass-template and terminates with fail if a fail-template + * matches. Matching against pass-templates occurs bevor matching + * agains fail-templates. If neither pass-templates nor + * fail-templates match, then the functions continues reading from + * the interface until a match arises, or timeout. The timeout value + * is given by PX_MAX_MSG_WAIT [5.0 seconds, FFS]. Finally, if + * p_forwardMtc is set to true, the last received message is stored + * to be fetched and used later by the main test component. Some + * special use cases: - Set p_skip.skipCounter to 0 to avoid + * skipping, i.e. no skippin - Set p_skip.skipCounter to 0 and + * p_skip.skipMessage to ? to skip exactly one message of any type + * will be skipped. - If the list of fail-templates is empty, then + * the function will wait for the first message maching a + * pass-message, or fail after timeout. + * @param p_passCriteria list of message templates which lead to pass + * @param p_failCriteria list of message templates which lead to fail + * @param p_skip + * Indicate how many messages from a specific sip template should be + * skipped prior to checking + * @param p_tpId The Test Purpose identifier + * @param p_forwardMtc + * indicate if the received Sip message should be forwarded to the + * mtc + * @param p_checkMessage + * indicate if the incomming message should only be checked + * (port.check) or consumed (port.receive). The check operation + * allows read access to the top element of incoming port queues + * without removing the top element from the queue. + */ + function f_imsIot_receive( + in template SipMessageList p_passCriteria, + in template SipMessageList p_failCriteria, + in template SkipType p_skip, + in charstring p_tpId, + in boolean p_forwardMtc, + in boolean p_checkMessage + ) runs on ImsInterfaceMonitor { + var integer v_size := sizeof(p_failCriteria); + var DefaultList v_defaultArray; + var integer i := 0; + var integer v_size_ai := sizeof(PX_AVAILABLE_INTERFACES); + +log ("### f_imsIot_receive: passCriteria=", p_passCriteria); +log ("### f_imsIot_receive: failCriteria=", p_failCriteria); + + // check if interface is available + for(i := 0; i < v_size_ai; i := i+1) { + if (PX_AVAILABLE_INTERFACES[i].interfaceName == vc_interfaceName) { + if (PX_AVAILABLE_INTERFACES[i].available == false) { + setverdict(inconc, self, "******f_imsIot_receive: Interface " & PX_AVAILABLE_INTERFACES[i].interfaceName & " not available and is not evaluated******" ); + } else { // Interface is available + v_defaultArray[0] := activate(a_default(p_tpId)); + f_activateImsSipDefaults(v_defaultArray, 1, p_failCriteria, fail, p_tpId, p_forwardMtc, p_checkMessage); + f_activateImsSipDefaults(v_defaultArray, v_size + 1, p_passCriteria, pass, p_tpId, p_forwardMtc, p_checkMessage); + f_gen_receive(p_tpId, p_skip); + + for (i := 0; i < sizeof(v_defaultArray); i := i + 1) { + deactivate(v_defaultArray[i]); + } + } + break; // Exit loop + } + } // 'for' loop + } + + /** + * @desc This function implements skipping of messages as well as timeout handling. + * Prior to calling this function the message to be cheked for should be added + * as defaults. + * This function is independent of a specific interface component. + * @param p_tpId The Test Purpose identifier + * @param p_skipCount Indicate how many messages should be skipped prior to checking + */ + function f_gen_receive( + in charstring p_tpId, + in template SkipType p_skip + ) runs on ImsInterfaceMonitor { + var integer skipCount := valueof(p_skip.skipCount); + tc_wait.start; + + alt { + // preamble (consume prior messages) + [skipCount > 0 and ischosen(p_skip.skipMessage.request)] dPort.receive (p_skip.skipMessage.request) { + skipCount := skipCount - 1; + log("***f_gen_receive: Message skipped (intentionally) when checking for " & p_tpId & " at interface " & vc_interfaceName & " ****"); + repeat; + } + [skipCount > 0 and ispresent(p_skip.skipMessage) and ischosen(p_skip.skipMessage.response)] dPort.receive (p_skip.skipMessage.response) { + skipCount := skipCount - 1; + log("***f_gen_receive: Message skipped (intentionally) when checking for " & p_tpId & " at interface " & vc_interfaceName & " ****"); + repeat; + } + [] tc_wait.timeout { + f_setConformanceVerdict(inconc, "***f_gen_receive: Timer tc_wait expired when waiting for incoming message in " & p_tpId & " at interface " & vc_interfaceName & " ****"); + } + } + + } + + /** + * @desc Activates for each entry in a expected IMS SIP message list a default + * for receiving that message and setting the verdict as desired + * @param p_default Reference to default array where deaults are to be added + * @param p_startIdx Index into default array after which references for + * defaults created in this function should be added + * @param p_list List of expected messages to be checked in default + * @param p_verdict Verdict to be set in case the incoming message matches + any of the expcted messages + * @param p_tpId Test Purpose identifir + */ + function f_activateImsSipDefaults( + inout DefaultList p_default, + in integer p_startIdx, + in template SipMessageList p_list, + in verdicttype p_verdict, + in charstring p_tpId, + in boolean p_forwardMtc, + in boolean p_checkMessage + ) runs on ImsInterfaceMonitor { + var integer v_size := sizeof(p_list); + var integer v_idx := p_startIdx; + + for (var integer i := 0; i < v_size; i := i + 1) { + if (ischosen(p_list[i].request)) { + p_default[v_idx] := activate( + a_receive_sipRequest(p_list[i].request,p_verdict, p_tpId, p_forwardMtc, p_checkMessage) + ); + } else { + p_default[v_idx] := activate( + a_receive_sipResponse(p_list[i].response,p_verdict, p_tpId, p_forwardMtc, p_checkMessage) + ); + } + v_idx := v_idx + 1; + } +//log ("### f_activateImsSipDefaults: ended"); + } + + }//end group + + + group misc { + + /** + * @desc + * This function generate a charstring with a given length used as + * message body. + * @param p_length length of the message body + * @return message body (charstring) + */ + function f_getMessageBody(in integer p_length) return charstring { + var charstring v_rtn := ""; + + for(var integer i := 0; i < p_length; i:=i+1) { + v_rtn := v_rtn & "a"; + } + + return v_rtn; + } + + function f_getContactAddr(in Contact contact) return SipUrl { + var SipUrl v_SipUrl; + + var ContactAddress addr := contact.contactBody.contactAddresses[0]; + + if (ischosen (addr.addressField.nameAddr)) { + v_SipUrl := addr.addressField.nameAddr.addrSpec; + } else { + v_SipUrl := addr.addressField.addrSpecUnion; + } + + return (v_SipUrl); + } + + } + +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_Templates.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_Templates.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_Templates.ttcn (revision 18) @@ -0,0 +1,2054 @@ +/* + * @author STF 370 + * @version $Id: $ + * @desc This module provides the templates for Interoperability tests. + */ + +module AtsImsIot_Templates { + + import from LibCommon_BasicTypesAndValues {type UInt16;} + + import from LibCommon_VerdictControl {type FncRetCode;} + + import from LibIot_TypesAndValues { + type + InterfaceInfoList, + ProtocolFilter, + GeneralConfigurationReq, + GeneralConfigurationRsp, + SetFilterReq, + SetFilterRsp, + StartTrafficCaptureReq, + StartTrafficCaptureRsp, + StopTrafficCaptureReq, + StopTrafficCaptureRsp, + IpAddress, + Status; + } + import from AtsImsIot_TypesAndValues {type SipMessage;} + + import from LibSip_SIPTypesAndValues all; + + import from LibSip_Templates all; + + import from LibIot_PIXITS { + modulepar + PX_IOT_TIMESTAMP_OFFSET, + PX_IOT_PCAP_SESSIONS_PATH, + PX_IOT_RECORD_MODE, + PX_IOT_EUTs_IFACE_INFO_LIST, + PX_IOT_FILE_MERGE_LIST, + PX_IOT_FILE_MERGE_PATH, + PX_IOT_MERGE_TOOL_PATH, + PX_IOT_IFACES; + } + + group adapterMsgTemplates { + template SetFilterReq m_SetFilterReq(ProtocolFilter p_protocol, InterfaceInfoList p_iterfaces) := { + protocol := p_protocol, + interfaceInfos := p_iterfaces + } + + template SetFilterRsp mw_SetFilterRsp(template Status p_status) := { + status := p_status + } + } + + + group sipTemplates { + + /** + * @desc SIP request template + * @param p_request SIP request + */ + template SipMessage mw_SipRequest(in template (present) Request p_request) := { + request := p_request + } + + /** + * @desc SIP response template + * @param p_response SIP response + */ + template SipMessage mw_SipResponse(in template (present) Response p_response) := { + response := p_response + } + }//end group + + group modifiedSIPBaseTemplates { + + /** + * + * @desc Message Request containing a message body greater than 1500 bytes. + */ + template MESSAGE_Request mdw_TP_IMS_4002_01(template CallId p_callId) modifies mw_MESSAGE_Request_Base := { + msgHeader := { + contact := * + }, + messageBody := { + textplain := pattern "?#(1500,)" + } + } + + /** + * + * @desc REGISTER Request containing secuity client header. + */ + template REGISTER_Request mdw_TP_IMS_5011_01_gm modifies mw_REGISTER_Request_Base := { + msgHeader := { + securityClient := ? + } + } + + /** + * + * @desc REGISTER Request containing secuity client header. + */ + template REGISTER_Request mdw_TP_IMS_5011_02_gm modifies mw_REGISTER_Request_Base := { + msgHeader := { + securityClient := ? + } + } + + /** + * + * @desc REGISTER Request checking TP_IMS_5011_01. + */ + template REGISTER_Request mdw_TP_IMS_5011_01p_ic ( charstring p_EUTHostname ) modifies mw_REGISTER_Request_Base := { + msgHeader := { + path := mw_PathDef (p_EUTHostname), + require := mw_Require ({"path", *}), + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "icid-value", paramValue := ?}, + {id := "orig-ioi", paramValue := ?}, + * + } + }, + authorization := m_Authorization(mw_credentialIntegrityNo), + securityClient := omit, + securityVerify :=omit, + pVisitedNetworkID := mw_PVisitedNetworkIDAny + } + } + + /** + * + * @desc REGISTER Request checking TP_IMS_5011_01. + */ + template REGISTER_Request mdw_TP_IMS_5011_01f_ic modifies mw_REGISTER_Request_Base := { + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "term-ioi", paramValue := ?}, + * + } + } + } + } + + /** + * + * @desc REGISTER Request checking TP_IMS_5134_01. + */ + template REGISTER_Request mdw_TP_IMS_5134_01_ic ( charstring p_EUTHostname ) modifies mw_REGISTER_Request_Base := { + msgHeader := { + path := mw_PathDef (p_EUTHostname) + } + } + + /** + * + * @desc REGISTER Request checking TP_IMS_5011_02. + */ + template REGISTER_Request mdw_TP_IMS_5011_02p_ic ( charstring p_EUTHostname ) modifies mw_REGISTER_Request_Base := { + msgHeader := { + path := mw_PathDef (p_EUTHostname), + require := mw_Require ({"path", *}), + pChargingVector := mw_PChargingVector({ + {id := "icid-value", paramValue := ?}, + {id := "orig-ioi", paramValue := ?}, + * + }), + authorization := m_Authorization(mw_credentialIntegrityYes), + securityClient := omit, + securityVerify :=omit, + pVisitedNetworkID := mw_PVisitedNetworkIDAny + } + } + + /** + * + * @desc REGISTER Request checking TP_IMS_5011_02. + */ + template REGISTER_Request mdw_TP_IMS_5011_02f_ic modifies mw_REGISTER_Request_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "term-ioi", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc REGISTER Request checking TP_IMS_5089_01. + */ + template REGISTER_Request mdw_TP_IMS_5089_01_ic_when modifies mw_REGISTER_Request_Base := { + msgHeader := { + authorization := m_Authorization(mw_credentialIntegrityNo) + } + } + + /** + * + * @desc REGISTER Request checking TP_IMS_5092_01. + */ + template REGISTER_Request mdw_TP_IMS_5092_01_ic_when modifies mw_REGISTER_Request_Base := { + msgHeader := { + authorization := m_Authorization(mw_credentialIntegrityNo) + } + } + + /** + * + * @desc 200 OK message for TP_IMS_5092_01 + */ + template Response mdw_TP_IMS_5092_01_ic (charstring p_EUTHostname, template SipUrl p_eutBUri) modifies mw_200OK_Base := { + msgHeader := { + path := mw_PathDef (p_EUTHostname), + pAssociatedURI := { + fieldName := P_ASSOCIATED_URI_E, + nameAddrList := ? + }, + pChargingVector := mw_PChargingVector({ // @TODO indicating operator_identifier of IMS_? (IUT_?)? + {id := "term-ioi", paramValue := ?}, + * + }), + serviceRoute := mw_ServiceRoute (p_eutBUri), + contact := { + fieldName := CONTACT_E, + contactBody := { + contactAddresses := ? + } + } + } + } + /** + * + * @desc 401 Unauthorized message checking f_mtc_check_TP_IMS_5089_01_ic. + */ + template Response mdw_TP_IMS_5089_01_ic modifies mw_401Unauthorized_Base := { + msgHeader := { + wwwAuthenticate := mw_WwwAuthenticate + } + } + + + /** + * + * @desc SUBSCRIBE checking TP_IMS_5044_01. + */ + template SUBSCRIBE_Request mdw_TP_IMS_5044_01_ic( + template SipUrl p_subscribe_uri, + template SipUrl p_eutAUri, + template charstring p_EUTB_PublicId + ) modifies mw_SUBSCRIBE_Request_Base := { + + requestLine := { + method := SUBSCRIBE_E, + requestUri := p_subscribe_uri, // @TODO + sipVersion := c_sipNameVersion + }, + msgHeader := { + fromField := mw_From (p_eutAUri), + toField := mw_To_NameAddr_SipUrl (p_EUTB_PublicId, ?, ?), + event := m_Event_reg, + expires := ?, // checked outside the template + pAssertedID := mw_PAssertedID(mw_PAssertedIDValue(p_eutAUri)), + pChargingVector := mw_PChargingVector({ + {id := "icid-value", paramValue := *}, + * + }) + } + } + + template SUBSCRIBE_Request mdw_TP_IMS_5405_01_ic + modifies mw_SUBSCRIBE_Request_Base := { + + requestLine := { + method := SUBSCRIBE_E, + requestUri := ?, + sipVersion := c_sipNameVersion + }, + msgHeader := { + via := mw_Via (?), // TODO + recordRoute := mw_recordroute(?), // @TODO + route := mw_route(?), // TODO + pChargingVector := omit + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5046_01 + */ + template INVITE_Request mdw_TP_IMS_5046_01_ic (template SipUrl p_pcscfEutAUri, template SipUrl p_userEutBUrl) + modifies mw_INVITE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := ? // complement (mw_routeBody(p_pcscfEutAUri)) // to be checked outside template + }, + via := { + fieldName := VIA_E, + viaBody := ? // superset(mw_ViaBody_interface(p_pcscfEutAUri.hostPort)) // to be checked outside template + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBody(p_pcscfEutAUri), *} + }, + pPreferredID := omit, + pAssertedID := mw_PAssertedID(mw_PAssertedIDValue(p_userEutBUrl)), + pChargingVector := mw_PChargingVector({ + {id := "icid-value", paramValue := *}, + * + }) + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5048_01 + */ + template INVITE_Request mdw_TP_IMS_5048_01_ic (template SipUrl p_pcscfEutAUri) + modifies mw_INVITE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + *, + complement(mw_routeBody(p_pcscfEutAUri)), + * + } + }, + via := { + fieldName := VIA_E, + viaBody := ? // superset(mw_ViaBody_interface(p_pcscfEutAUri.hostPort)) // to be checked outside template + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBody(p_pcscfEutAUri), *} + } + } + } + + /** + * + * @desc BYE Request checking TP_IMS_5052_01 on MW + */ + template BYE_Request mdw_TP_IMS_5052_01_p_ic(template CallId p_callId, template RecordRoute p_route) + modifies mw_BYE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := * + }, + recordRoute := p_route + } + } + + template BYE_Request mdw_TP_IMS_5052_01_f_ic( + template CallId p_callId, + template SipUrl p_pcscfEutAUri) + modifies mw_BYE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + *, + mw_routeBody(p_pcscfEutAUri), + * + } + } + } + } + + + /** + * + * @desc 180 Ringing Response checking TP_IMS_5055_01 on MW + */ + template Response mdw_TP_IMS_5055_01_ic(template SipUrl p_pcscfEutAUri, template SipUrl p_userEutAUri) + modifies mw_180Ringing_Base := { + msgHeader := { + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBody(p_pcscfEutAUri), *} + }, + pPreferredID := omit, + pAssertedID := mw_PAssertedID(mw_PAssertedIDValue(p_userEutAUri))//TODO containing public identitiy sent in P-Called_Party-ID header in the initial request + } + } + + /** + * + * @desc 200 OK Response checking TP_IMS_5055_02 on MW + */ + template Response mdw_TP_IMS_5055_02_ic(template SipUrl p_pcscfEutAUri, template SipUrl p_userEutAUri) + modifies mw_200OK_Base := { + msgHeader := { + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBody(p_pcscfEutAUri), *} + }, + pPreferredID := omit, + pAssertedID := mw_PAssertedID(mw_PAssertedIDValue(p_userEutAUri))//TODO containing public identitiy sent in P-Called_Party-ID header in the initial request + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5067_01 on MW + */ + template INVITE_Request mdw_TP_IMS_5067_01_ic + modifies mw_INVITE_Request_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "access-network-charging-info", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc CANCEL Request checking TP_IMS_572_02 on gm + */ + template CANCEL_Request mdw_TP_IMS_5072_02_gm (template CallId p_callId) + modifies mw_CANCEL_Request_Base := { + msgHeader := { + reason := { + fieldName := REASON_E, + reasonValues := { + { + token := "503 Service Unavailable", + reasonParams := * + }, + * + } + } + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5080_01 on MW + */ + template INVITE_Request mdw_TP_IMS_5080_01_ic + modifies mw_INVITE_Request_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "access-network-charging-info", paramValue := ?}, //note access-network-charging-info should be updated + * + }) + } + } + + /** + * + * @desc 200 OK Response checking TP_IMS_5082_01 on MW + */ + template Response mdw_TP_IMS_5082_01_ic + modifies mw_200OK_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "access-network-charging-info", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc SUBSCRIBE checking TP_IMS_5096_01. + */ + template SUBSCRIBE_Request mdw_TP_IMS_5096_01_ic_when modifies mw_SUBSCRIBE_Request_Base := { + msgHeader := { + event := m_Event_reg + } + } + + /** + * @desc INVITE Request checking TP_IMS_5097_01 + */ + template INVITE_Request mdw_TP_IMS_5097_01_ic (template SipUrl p_SCSCF_SIP_URI) + modifies mw_INVITE_Request_Base := { + msgHeader := { + route := ({ + fieldName := ROUTE_E, + routeBody := { + *, + complement(mw_routeBody(p_SCSCF_SIP_URI)), + * + } + }, omit), + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBody(p_SCSCF_SIP_URI), *} + }, + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + *, + {id := "icid-value", paramValue := ?}, + *, + {id := "orig-ioi", paramValue := ?}, + *, + complement({id := "term-ioi", paramValue := ?}), + *, + complement({id := "access-network-charging-info", paramValue := ?}), + * + } + } + } + } + + + /** + * @desc INVITE Request checking TP_IMS_5097_02 + */ + template INVITE_Request mdw_TP_IMS_5097_02_ic ( + template SipUrl p_SIP_URI, + template SipUrl p_TEL_URI) + modifies mw_INVITE_Request_Base := { + msgHeader := { + pAssertedID := { + fieldName := P_ASSERTED_ID_E, + pAssertedIDValueList := { + *, + ({ nameAddr := mw_NameAddr(p_SIP_URI)}, {addrSpecUnion := mw_SIP_URI_Base}), + *, + ({nameAddr := mw_NameAddr(p_TEL_URI)}, {addrSpecUnion := mw_TEL_URI_Base}), + * + } + } + } + } + + /** + * @desc INVITE Request checking TP_IMS_5097_04 + */ + template INVITE_Request mdw_TP_IMS_5097_04_gm(template SipUrl p_requestUri) + modifies mw_INVITE_Request_Base := { + requestLine := { + requestUri := p_requestUri + } + } + + /** + * @desc INVITE Request checking TP_IMS_5097_04 + */ + template INVITE_Request mdw_TP_IMS_5097_04_ic(template SipUrl p_requestUri) + modifies mw_INVITE_Request_Base := { + requestLine := { + requestUri := p_requestUri + }, + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + *, + complement({id := "access-network-charging-info", paramValue := ?}), + * + } + } + + } + } + + /** + * + * @desc BYE Request checking TP_IMS_5107_01 on MW + */ + template BYE_Request mdw_TP_IMS_5107_01_ic(template CallId p_callId, template SipUrl p_SCSCF_SIP_URI) + modifies mw_BYE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + *, + complement(mw_routeBody(p_SCSCF_SIP_URI)), + * + } + } + } + } + + /** + * + * @desc ACK Request checking TP_IMS_5107_02 on MW + */ + template ACK_Request mdw_TP_IMS_5107_02_ic(template CallId p_callId, template SipUrl p_SCSCF_SIP_URI) + modifies mw_ACK_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + *, + complement(mw_routeBody(p_SCSCF_SIP_URI)), + * + } + } + } + } + + /** + * + * @desc CANCEL Request checking TP_IMS_5107_03 on MW + */ + template CANCEL_Request mdw_TP_IMS_5107_03_ic (template CallId p_callId, template SipUrl p_SCSCF_SIP_URI) + modifies mw_CANCEL_Request_Base := { + msgHeader := { + route := ( + omit, + { + fieldName := ROUTE_E, + routeBody := { + *, + complement(mw_routeBody(p_SCSCF_SIP_URI)), + * + } + } + ) + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5108_01 on MW + */ + template INVITE_Request mdw_TP_IMS_5108_01_ic( + template SipUrl p_SCSCF_Uri, + template GenericParam p_param + ) modifies mw_INVITE_Request_Base := { + msgHeader := { + route := (omit, + { + fieldName := ROUTE_E, + routeBody := { + *, + complement(mw_routeBody(p_SCSCF_Uri)), + * + } + } + ), + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {{ + nameAddr := { + displayName := *, + addrSpec := p_SCSCF_Uri + }, + rrParam := * + }, *} + }, + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + p_param, + * + } + } + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5108_01_f on MW + * ifpresent ioi params than fail + */ + template INVITE_Request mdw_TP_IMS_5108_01_f_ic + modifies mw_INVITE_Request_Base := { + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "orig-ioi", paramValue := ?}, + {id := "term-ioi", paramValue := ?}, + * + } + } + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5108_03 on ISC + */ + template INVITE_Request mdw_TP_IMS_5108_03_isc( + template SipUrl p_ASB_Uri, + template SipUrl p_SCSCF_Uri + ) modifies mw_INVITE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + { + nameAddr := { + displayName := *, + addrSpec := p_ASB_Uri + }, + rrParam := * + }, + { + nameAddr := { + displayName := *, + addrSpec := p_SCSCF_Uri + }, + rrParam := * + }, + * + + } + }, + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "orig-ioi", paramValue := ?}, + * + } + } + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5108_03_f on ISC + * ifpresent ioi params than fail + */ + template INVITE_Request mdw_TP_IMS_5108_03_f_isc + modifies mw_INVITE_Request_Base := { + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "term-ioi", paramValue := *}, + * + } + } + } + } + + /** + * + * @desc 180 Ringing Response checking TP_IMS_5115_01 on MW + */ + template Response mdw_TP_IMS_5115_01_ic + modifies mw_180Ringing_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "orig-ioi", paramValue := ?}, + {id := "term-ioi", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc 200 OK Response checking TP_IMS_5115_02 on MW + */ + template Response mdw_TP_IMS_5115_02_ic + modifies mw_200OK_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "orig-ioi", paramValue := ?}, + {id := "term-ioi", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc 180 Ringing Response checking TP_IMS_5115_03 on MW + */ + template Response mdw_TP_IMS_5115_03_ic( + template SipUrl p_SIP_URI, + template SipUrl p_TEL_URI) + modifies mw_180Ringing_Base := { + msgHeader := { + pAssertedID := { + fieldName := P_ASSERTED_ID_E, + pAssertedIDValueList := { + *, + { nameAddr := mw_NameAddr(p_SIP_URI)}, + *, + {nameAddr := mw_NameAddr(p_TEL_URI)}, + * + } + } + } + } + + /** + * + * @desc 200 OK Response checking TP_IMS_5115_04 on MW + */ + template Response mdw_TP_IMS_5115_04_ic( + template SipUrl p_SIP_URI, + template SipUrl p_TEL_URI) + modifies mw_200OK_Base := { + msgHeader := { + pAssertedID := { + fieldName := P_ASSERTED_ID_E, + pAssertedIDValueList := { + *, + { nameAddr := mw_NameAddr(p_SIP_URI)}, + *, + {nameAddr := mw_NameAddr(p_TEL_URI)}, + * + } + } + } + } + + /** + * + * @desc 200 OK Response checking TP_IMS_5115_08 on MW + */ + template Response mdw_TP_IMS_5115_08_ic + modifies mw_200OK_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "orig-ioi", paramValue := ?}, + {id := "term-ioi", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc 180 Ringing Response checking TP_IMS_5131_01 on MW + */ + template Response mdw_TP_IMS_5131_01_ic + modifies mw_180Ringing_Base := { + msgHeader := { + pChargingFunctionAddresses := omit + } + } + + /** + * + * @desc 200 OK Response checking TP_IMS_5131_02 on MW + */ + template Response mdw_TP_IMS_5131_02_ic + modifies mw_200OK_Base := { + msgHeader := { + pChargingFunctionAddresses := omit + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5135_01 + */ + template INVITE_Request mdw_TP_IMS_5135_01_ic (template SipUrl p_ibcfEutAUri) + modifies mw_INVITE_Request_Base := { + msgHeader := { + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBody(p_ibcfEutAUri), *} + } + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5137_01 + */ + template INVITE_Request mdw_TP_IMS_5137_01_ic (template SipUrl p_ibcfEutAUri) + modifies mw_INVITE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + mw_routeBodyTH(p_ibcfEutAUri), + * + } + }, + via := { + fieldName := VIA_E, + viaBody := {{ + sentProtocol := *, + sentBy := *, + viaParams :={{ + id:="tokenized-by", + paramValue := * + }} + }} + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBodyTH(*), *} + } + } + } + + /** + * + * @desc 180 Ringing Response checking TP_IMS_5137_02 on MW + */ + template Response mdw_TP_IMS_5137_02_ic + modifies mw_180Ringing_Base := { + msgHeader := { + via := { + fieldName := VIA_E, + viaBody := {{ + sentProtocol := *, + sentBy := *, + viaParams :={{ + id:="tokenized-by", + paramValue := * + }} + }} + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBodyTH(*), *} + } + } + } + + /** + * + * @desc 200 OK Response checking TP_IMS_5137_03 on MW + */ + template Response mdw_TP_IMS_5137_03_ic + modifies mw_200OK_Base := { + msgHeader := { + via := { + fieldName := VIA_E, + viaBody := {{ + sentProtocol := *, + sentBy := *, + viaParams :={{ + id:="tokenized-by", + paramValue := * + }} + }} + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBodyTH(*), *} + } + } + } + + /** + * + * @desc BYE Request checking TP_IMS_5139_01 on MW + */ + template BYE_Request mdw_TP_IMS_5139_01_ic( + template CallId p_callId, + template SipUrl p_UE_URI, + template To p_to, + template From p_from, + template CSeq p_cSeq, + template Route p_route + ) modifies mw_BYE_Request_Base := { + requestLine := { + requestUri := p_UE_URI + }, + msgHeader := { + callId := p_callId, + cSeq := p_cSeq, + fromField := p_from, + reason := ?, + route := p_route, + toField := p_to + } + } + + + /** + * + * @desc BYE Request checking TP_IMS_5301_01 on MW + */ + template BYE_Request mdw_TP_IMS_5301_01_ic(template CallId p_callId, template SipUrl p_SCSCF_SIP_URI) + modifies mw_BYE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + *, + complement(mw_routeBody(p_SCSCF_SIP_URI)), + * + } + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBody(p_SCSCF_SIP_URI), *} + } + } + } + + /** + * + * @desc 180 Ringing Response checking TP_IMS_5308_01 on GM + */ + template Response mdw_TP_IMS_5308_01_gm + modifies mw_180Ringing_Base := { + msgHeader := { + pChargingFunctionAddresses := ? + } + } + + /** + * + * @desc 180 Ringing Response checking TP_IMS_5308_01 on ISC + */ + template Response mdw_TP_IMS_5308_01_isc + modifies mw_180Ringing_Base := { + msgHeader := { + pChargingFunctionAddresses :=? + } + } + + /** + * + * @desc 200 OK Response checking TP_IMS_5308_02 on GM + */ + template Response mdw_TP_IMS_5308_02_gm + modifies mw_200OK_Base := { + msgHeader := { + pChargingFunctionAddresses := ? + } + } + + /** + * + * @desc 200 OK Response checking TP_IMS_5308_02 on ISC + */ + template Response mdw_TP_IMS_5308_02_isc + modifies mw_200OK_Base := { + msgHeader := { + pChargingFunctionAddresses := ? + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5310_01 on GM + */ + template INVITE_Request mdw_TP_IMS_5310_01_gm + modifies mw_INVITE_Request_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "access-network-charging-info", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5310_01 on AS + */ + template INVITE_Request mdw_TP_IMS_5310_01_isc + modifies mw_INVITE_Request_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "access-network-charging-info", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc 200 OK Response checking TP_IMS_5312_01 on MW + */ + template Response mdw_TP_IMS_5312_01_ic + modifies mw_200OK_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "access-network-charging-info", paramValue := ?}, + * + }) + } + } + /** + * + * @desc 200 OK Response checking TP_IMS_5312_01 on AS + */ + template Response mdw_TP_IMS_5312_01_isc + modifies mw_200OK_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "access-network-charging-info", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc 433 Anonymity Disallowe Response checking TP_IMS_5313_01 on MW + */ + template Response mdw_TP_IMS_5313_01_ic + modifies mw_433Anony_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "access-network-charging-info", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc 433 Anonymity Disallowe Response checking TP_IMS_5313_01 on AS + */ + template Response mdw_TP_IMS_5313_01_isc + modifies mw_433Anony_Base := { + msgHeader := { + pChargingVector := mw_PChargingVector({ + {id := "access-network-charging-info", paramValue := ?}, + * + }) + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5404_01 on GM + */ + template INVITE_Request mdw_TP_IMS_5404_01_gm + modifies mw_INVITE_Request_Base := { + msgHeader := { + pChargingFunctionAddresses := ? + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5404_01 on MW + */ + template INVITE_Request mdw_TP_IMS_5404_01_ic + modifies mw_INVITE_Request_Base := { + msgHeader := { + pChargingFunctionAddresses := omit + } + } + + /** + * + * @desc ACK Request checking TP_IMS_5408_01 on MW + */ + template ACK_Request mdw_TP_IMS_5408_01_ic(template CallId p_callId, template SipUrl p_IBCF_SIP_URI) + modifies mw_ACK_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + mw_routeBodyTH(p_IBCF_SIP_URI), + * + } + }, + via := { + fieldName := VIA_E, + viaBody := {{ + sentProtocol := *, + sentBy := *, + viaParams :={{ + id:="tokenized-by", + paramValue := * + }} + }} + } + } + } + + /** + * + * @desc BYE Request checking TP_IMS_5408_02 on MW + */ + template CANCEL_Request mdw_TP_IMS_5408_02_ic(template CallId p_callId, template SipUrl p_IBCF_SIP_URI) + modifies mw_CANCEL_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + mw_routeBodyTH(p_IBCF_SIP_URI), + * + } + }, + via := { + fieldName := VIA_E, + viaBody := {{ + sentProtocol := *, + sentBy := *, + viaParams :={{ + id:="tokenized-by", + paramValue := * + }} + }} + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBodyTH(*), *} + } + } + } + + /** + * + * @desc BYE Request checking TP_IMS_5408_03 on MW + */ + template BYE_Request mdw_TP_IMS_5408_03_ic(template CallId p_callId, template SipUrl p_IBCF_SIP_URI) + modifies mw_BYE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + mw_routeBodyTH(p_IBCF_SIP_URI), + * + } + }, + via := { + fieldName := VIA_E, + viaBody := {{ + sentProtocol := *, + sentBy := *, + viaParams :={{ + id:="tokenized-by", + paramValue := * + }} + }} + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBodyTH(*), *} + } + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5408_04 + */ + template INVITE_Request mdw_TP_IMS_5408_04_ic (template SipUrl p_ibcfEutAUri) + modifies mw_INVITE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + mw_routeBodyTH(p_ibcfEutAUri), + * + } + }, + via := { + fieldName := VIA_E, + viaBody := {{ + sentProtocol := *, + sentBy := *, + viaParams :={{ + id:="tokenized-by", + paramValue := * + }} + }} + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {mw_routeBodyTH(*), *} + } + } + } + + /** + * + * @desc INVITE Request checking TP_IMS_5097_09 + */ + template INVITE_Request mdw_TP_IMS_5097_09_isc (template SipUrl p_EutB_ASUri) + modifies mw_INVITE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := {mw_routeBody(p_EutB_ASUri), *} + }, + pChargingFunctionAddresses := ?, + pChargingVector := mw_PChargingVector({ + {id := "orig-ioi", paramValue := *}, // NOTE indicating also operator identifier for IMSA + * + }) + } + } + + /** + * @desc INVITE Request checking TP_IMS_5097_09 false + */ + template INVITE_Request mdw_TP_IMS_5097_09_f_isc + modifies mw_INVITE_Request_Base := { + + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "term-ioi", paramValue := *}, + * + } + } + } + } + + template MESSAGE_Request mdw_TP_IMS_5097_05_p_ic( + template CallId p_callId + ) modifies mw_MESSAGE_Request_Base := { + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "icid-value", paramValue := ?}, + {id := "orig-ioi", paramValue := ?}, + * + } + }, + pAccessNetworkInfo := omit + } + } + + template MESSAGE_Request mdw_TP_IMS_5097_05_f2_ic( + template CallId p_callId, + template SipUrl p_SCSCF_SIP_URI + ) modifies mw_MESSAGE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + mw_routeBody(p_SCSCF_SIP_URI), + * + } + } + } + } + + template MESSAGE_Request mdw_TP_IMS_5097_05_f_ic( + template CallId p_callId + ) modifies mw_MESSAGE_Request_Base := { + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "term-ioi", paramValue := ?}, + {id := "access-network-charging-info", paramValue := ?}, + * + } + } + } + } + + template MESSAGE_Request mdw_TP_IMS_5097_08_gm( + template CallId p_callId + ) modifies mw_MESSAGE_Request_Base := { + requestLine := { requestUri := mw_TEL_URI_Base } + } + + template MESSAGE_Request mdw_TP_IMS_5097_08_ic( + template CallId p_callId + ) modifies mw_MESSAGE_Request_Base := { + requestLine := { + requestUri := mw_SIP_URI_Base + }, + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + complement({id := "access-network-charging-info", paramValue := ?}), + * + } + } + } + } + + template MESSAGE_Request mdw_TP_IMS_5097_07_ic( + template CallId p_callId, + template SipUrl p_SIP_URI, + template SipUrl p_TEL_URI) + modifies mw_MESSAGE_Request_Base := { + msgHeader := { + pAssertedID := { + fieldName := P_ASSERTED_ID_E, + pAssertedIDValueList := { + ({nameAddr := mw_NameAddr(p_SIP_URI)}, {addrSpecUnion := mw_SIP_URI_Base}), + ({nameAddr := mw_NameAddr(p_TEL_URI)}, {addrSpecUnion := mw_TEL_URI_Base}), + * + } + } + } + } + + template MESSAGE_Request mdw_TP_IMS_5108_02a_ic( + template CallId p_callId + ) modifies mw_MESSAGE_Request_Base := { + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "icid-value", paramValue := ?}, + * + } + } + } + } + + template MESSAGE_Request mdw_TP_IMS_5108_02b_p_ic( + template CallId p_callId, + template SipUrl p_SCSCF_Uri, + template GenericParam p_param + ) modifies mw_MESSAGE_Request_Base := { + msgHeader := { + route := omit, // TODO TP is not clear please double check + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := {{ + nameAddr := { + displayName := *, + addrSpec := p_SCSCF_Uri + }, + rrParam := * + }} + }, + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + p_param, + * + } + } + } + } + + template MESSAGE_Request mdw_TP_IMS_5108_02b_f_ic( + template CallId p_callId + ) modifies mw_MESSAGE_Request_Base := { + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "orig-ioi", paramValue := ?}, + {id := "term-ioi", paramValue := ?}, + * + } + } + } + } + + + /** + * @desc INVITE Request checking TP_IMS_5120_01 + */ + template INVITE_Request mdw_TP_IMS_5120_01_ic( + template SipUrl p_SCSCF_URI + ) modifies mw_INVITE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + complement(mw_routeBody(p_SCSCF_URI)), + * + } + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := { + mw_routeBody(p_SCSCF_URI), + * + } + } + } + } + + template Response mw_TP_IMS_5121_02_ic modifies mdw_2XX_Base := { + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + complement({id := "access-network-charging-info", paramValue := ?}), + * + } + } + } + } + + template Response mw_TP_IMS_5117_02_ic modifies mdw_2XX_Base := { + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + complement({id := "access-network-charging-info", paramValue := ?}), + * + } + } + } + } + + template Response mw_TP_IMS_5117_06_ic modifies mdw_2XX_Base := { + msgHeader := { + pAssertedID := { + fieldName := P_ASSERTED_ID_E, + pAssertedIDValueList := { + {nameAddr := mw_NameAddr(mw_SIP_URI_Base)}, + {nameAddr := mw_NameAddr(mw_TEL_URI_Base)}, + * + } + } + } + } + + template Response mw_TP_IMS_5118_01_ic modifies mw_200OK_Base := { + msgHeader := { + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "orig-ioi", paramValue := ?}, + {id := "term-ioi", paramValue := ?}, + * + } + } + } + } + + template MESSAGE_Request mdw_TP_IMS_5050_01_ic( + template CallId p_callId, + template SipUrl p_PCSCF_URI, + template SipUrl p_UE_A_URI + ) modifies mw_MESSAGE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + { + nameAddr := { + displayName := *, + addrSpec := complement(p_PCSCF_URI) + }, + rrParam := * + },* + } + }, + pPreferredID := omit, + pAssertedID := mw_PAssertedID(mw_PAssertedIDValue(p_UE_A_URI)), + pChargingVector := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := { + {id := "icid-value", paramValue := ?}, + * + } + } + } + } + + template Response mdw_2XX_Base modifies m_Response_Dummy := { + statusLine := {c_sipNameVersion, (200..299), *}, + msgHeader := ?, + messageBody := *, + payload := * + } + + template Response mw_100Trying_Base modifies m_Response_Dummy := + { + statusLine := c_statusLine100, + msgHeader := ?, + messageBody := *, + payload := * + } + + template Response mw_180Ringing_Base modifies m_Response_Dummy := + { + statusLine := c_statusLine180, + msgHeader := ?, + messageBody := *, + payload := * + } + template Response mw_200OK_Base modifies m_Response_Dummy := + { + statusLine := c_statusLine200, + msgHeader := ?, + messageBody := *, + payload := * + } + template Response mw_202Accepted_Base modifies m_Response_Dummy := + { + statusLine := c_statusLine202, + msgHeader := ?, + messageBody := *, + payload := * + } + template Response mw_401Unauthorized_Base modifies m_Response_Dummy := + { + statusLine := {c_sipNameVersion, 401, ?}, + msgHeader := ?, + messageBody := *, + payload := * + } + + template Response mdw_4XX_Base modifies m_Response_Dummy := + { + statusLine := {c_sipNameVersion, (400..499), *}, + msgHeader := ?, + messageBody := *, + payload := * + } + template Response mw_403Forbidden_Base modifies m_Response_Dummy := + { + statusLine := {c_sipNameVersion, 403, ?}, + msgHeader := ?, + messageBody := *, + payload := * + } + + template Response mw_404NotFound_Base modifies m_Response_Dummy := + { + statusLine := {c_sipNameVersion, 404, ?}, + msgHeader := ?, + messageBody := *, + payload := * + } + + template Response mdw_404Or604NotFound_Base modifies m_Response_Dummy := + { + statusLine := ({c_sipNameVersion, 404, ?}, {c_sipNameVersion, 604, ?}), + msgHeader := ?, + messageBody := *, + payload := * + } + + template Response mdw_408Or5XX_Base modifies m_Response_Dummy := + { + statusLine := {c_sipNameVersion, (408,(500..599)), *}, + msgHeader := ?, + messageBody := *, + payload := * + } + + template Response mw_433Anony_Base modifies m_Response_Dummy := + { + statusLine := c_statusLine433, + msgHeader := ?, + messageBody := *, + payload := * + } + + template REGISTER_Request mdw_TP_IMS_5088_01_gm modifies mw_REGISTER_Request_Base := { + msgHeader := {authorization := m_Authorization(mw_credentialIntegrityYes)} + } + + template NOTIFY_Request mdw_TP_IMS_5088_01_ic(template CallId p_callId, template SipUrl p_PCSCF_SIP_URI) modifies mw_NOTIFY_Request_Base := { + requestLine := { requestUri := p_PCSCF_SIP_URI }, + msgHeader := { + event := { + fieldName := EVENT_E, + eventType := pattern "*reg*", + eventParams := *}, + route := ? }, // TODO route header indicating the original Route_header from SUBSCRIBE (SUBSCRIBE not defined in the test description) + messageBody := ? // TODO + } + + template NOTIFY_Request mdw_TP_IMS_5093_01_UE_ic(template CallId p_callId, template SipUrl p_UE_SIP_URI) modifies mw_NOTIFY_Request_Base := { + requestLine := { requestUri := p_UE_SIP_URI }, + msgHeader := { + event := { + fieldName := EVENT_E, + eventType := pattern "*reg*", + eventParams := *}, + route := ? }, // TODO route header indicating the original Route_header from SUBSCRIBE (SUBSCRIBE not defined in the test description) + messageBody := ? // TODO + } + + template NOTIFY_Request mdw_TP_IMS_5093_01_IMS_ic(template CallId p_callId, template SipUrl p_PCSCF_SIP_URI) modifies mw_NOTIFY_Request_Base := { + requestLine := { requestUri := p_PCSCF_SIP_URI }, + msgHeader := { + event := { + fieldName := EVENT_E, + eventType := pattern "*reg*", + eventParams := *}, + route := ? }, // TODO route header indicating the original Route_header from SUBSCRIBE (SUBSCRIBE not defined in the test description) + messageBody := ? // TODO + } + + template NOTIFY_Request mdw_TP_IMS_5094_01_UE(template CallId p_callId, template SipUrl p_UE_SIP_URI) modifies mw_NOTIFY_Request_Base := { + requestLine := { requestUri := p_UE_SIP_URI }, + msgHeader := { + event := { + fieldName := EVENT_E, + eventType := pattern "*reg*", + eventParams := *}, + route := ? }, // TODO route header indicating the original Route_header from SUBSCRIBE (SUBSCRIBE not defined in the test description) + messageBody := ? // TODO + } + + template NOTIFY_Request mdw_TP_IMS_5094_01_IMS_ic(template CallId p_callId, template SipUrl p_PCSCF_SIP_URI) modifies mw_NOTIFY_Request_Base := { + requestLine := { requestUri := p_PCSCF_SIP_URI }, + msgHeader := { + event := { + fieldName := EVENT_E, + eventType := pattern "*reg*", + eventParams := *}, + route := ? }, // TODO route header indicating the original Route_header from SUBSCRIBE (SUBSCRIBE not defined in the test description) + messageBody := ? // TODO + } + + + /** + * @desc INVITE Request checking TP_IMS_5106_01 + */ + template INVITE_Request mdw_TP_IMS_5106_01_ic( + template SipUrl p_SCSCF_URI + ) modifies mw_INVITE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + complement(mw_routeBody(p_SCSCF_URI)), + * + } + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := { + mw_routeBody(p_SCSCF_URI), + * + } + }, + pAccessNetworkInfo := omit, + pChargingVector := mw_PChargingVector({ + {id := "icid-value", paramValue := *}, + * + }) + } + } + + /** + * @desc VYE Request checking TP_IMS_5074_01 + */ + template BYE_Request mdw_TP_IMS_5074_01_ic( + template CallId p_callId, + template SipUrl p_UE_URI // must be the IP address + ) modifies mw_BYE_Request_Base := { + requestLine := { + requestUri := p_UE_URI + }, + msgHeader := { + toField := ?, + fromField := ?, + cSeq := ?, + route := ?, + reason := { + fieldName := REASON_E, + reasonValues := { + { + token := "503 Service Unavailable", + reasonParams := * + }, + * + } + } + } + } + + + /** + * @desc UPDATE Request checking TP_IMS_5106_02 + */ + template UPDATE_Request mdw_TP_IMS_5106_02_p_ic( + template CallId p_callId, + template SipUrl p_SCSCF_URI + ) modifies mw_UPDATE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := * + }, + recordRoute := { + fieldName := RECORD_ROUTE_E, + routeBody := { + *, + mw_routeBody(p_SCSCF_URI), + * + } + }, + pChargingVector := mw_PChargingVector({ + {id := "icid-value", paramValue := *}, + * + }) + } + } + + + template UPDATE_Request mdw_TP_IMS_5106_02_f_ic( + template CallId p_callId, + template SipUrl p_SCSCF_URI + ) modifies mw_UPDATE_Request_Base := { + msgHeader := { + route := { + fieldName := ROUTE_E, + routeBody := { + mw_routeBody(p_SCSCF_URI), + * + } + } + } + } + + }//end group + group HeaderTemplates { + + template Path mw_PathDef (charstring p_Host) := { + fieldName := PATH_E, + pathValues := {{ + nameAddr:= { + displayName := *, + addrSpec := { + scheme := "sip", + userInfo := *, + hostPort := { + host := p_Host, + portField := *}, + urlParameters := *, + headers := omit} + }, + rrParam := omit + }} + } // template + + template Require mw_Require (template OptionTag_List p_optionsList) := { + fieldName := REQUIRE_E, + optionsTags := p_optionsList + } // template + + template PChargingVector mw_PChargingVector (template SemicolonParam_List p_List) := { + fieldName := P_CHARGING_VECTOR_E, + chargeParams := p_List + } // template + + template ServiceRoute mw_ServiceRoute (template SipUrl p_eutAddr) := { + fieldName := SERVICE_ROUTE_E, + routeBody := { + { + nameAddr := { + displayName := *, + addrSpec := p_eutAddr + }, + rrParam := * + }, + * + } + } // template + + + + template PVisitedNetworkID mw_PVisitedNetworkIDAny := { + fieldName := P_VISITED_NETWORK_E, + vNetWorkSpec := ? + } // template + + template PAssociatedURI mw_PAssociatedURI (template SemicolonParam_List p_SemicolonParam_List):= + { + fieldName := P_ASSOCIATED_URI_E, + nameAddrList:= { + {nameAddr := *, + genericParams := p_SemicolonParam_List + }, + * + } + } + template WwwAuthenticate mw_WwwAuthenticate := { + fieldName := WWW_AUTHENTICATE_E, + challenge := { + digestCln := { //{id := "username", paramValue := ?}, + {id := "realm", paramValue := ?}, // TODO containing operator ID + {id := "nonce", paramValue := ?}, + {id := "rand", paramValue := ?}, + {id := "autn", paramValue := ?}, + {id := "ik", paramValue := ?}, + {id := "ck", paramValue := ?}, + {id := "algorithm", paramValue := "AKAv1-MD5"}, + *} + + } + } // template + + + } // end group HeaderTemplates + + group AuxiliaryInformationElementTemplates { + + template Credentials mw_credentialIntegrityYes := { + otherResponse := {authScheme := ?, authParams := { {"integrity-protected", "yes"},*} // TODO + }} + template Credentials mw_credentialIntegrityNo := { + otherResponse := {authScheme := ?, authParams := { {"integrity-protected", "no"},*} // TODO + }} + + template RouteBody mw_routeBodyTH (template SipUrl p_sipurl):= { + nameAddr := + { + displayName := *, + addrSpec := p_sipurl + }, + rrParam := {{ + id:="tokenized-by", + paramValue := * + }} + } + + template NameAddr mw_NameAddr(template SipUrl p_URI) := { + displayName := *, + addrSpec := p_URI + } + + template SipUrl mw_SIP_URI_Base := { + scheme := "sip", // meaning "not tel" + userInfo := ?, + hostPort := ?, + urlParameters := *, + headers := * + } + + template SipUrl mw_TEL_URI_Base := { + scheme := "tel", + userInfo := ?, + hostPort := *, + urlParameters := *, + headers := * + } + + } //end group + + group adapterTemplates { + + template GeneralConfigurationReq m_generalConfigurationReq_offline := { + captureProcessIpAddress := "127.0.0.1", + captureProcessPort := 5501, + captureMode := { + offlineCapture := { + offset := PX_IOT_TIMESTAMP_OFFSET, + captureSource := { + sessionsPath := PX_IOT_PCAP_SESSIONS_PATH, + mergeFileList := { + mergeFileList := { }, + mergeFilePath := "", + mergeToolPath := "" + } + } + } + }, + eutInfoList := omit + } + template GeneralConfigurationReq m_generalConfigurationReq_online := { + captureProcessIpAddress := "127.0.0.1", + captureProcessPort := 5501, + captureMode := { + liveCpature := { + physicalInterfaces := { + PX_IOT_IFACES + }, + recordMode := PX_IOT_RECORD_MODE + } + }, + eutInfoList := PX_IOT_EUTs_IFACE_INFO_LIST + } + template GeneralConfigurationReq m_generalConfigurationReq_merge := { + captureProcessIpAddress := "127.0.0.1", + captureProcessPort := 5501, + captureMode := { + offlineCapture := { + offset := PX_IOT_TIMESTAMP_OFFSET, + captureSource := { + sessionsPath := "", + mergeFileList := { + mergeFileList := PX_IOT_FILE_MERGE_LIST, + mergeFilePath := PX_IOT_FILE_MERGE_PATH, + mergeToolPath := PX_IOT_MERGE_TOOL_PATH + } + } + } + }, + eutInfoList := omit + } + template GeneralConfigurationRsp m_generalConfigurationRsp_success := { + status := { + code := e_success, + reason := * + } + } + template GeneralConfigurationRsp m_generalConfigurationRsp_timeout := { + status := { + code := e_timeout, + reason := * + } + } + template GeneralConfigurationRsp m_generalConfigurationRsp_error := { + status := { + code := e_error, + reason := * + } + } + template GeneralConfigurationRsp m_generalConfigurationRsp_any := { + status := { + code := *, + reason := * + } + } + template StartTrafficCaptureReq m_startTrafficCaptureReq := { + } + template StartTrafficCaptureRsp m_startTrafficCaptureRsp_any := { + status := { + code := *, + reason := * + } + } + template StopTrafficCaptureReq m_stopTrafficCaptureReq :={ + } + template StopTrafficCaptureRsp m_stopTrafficCaptureRsp_any := { + status := { + code := *, + reason := * + } + } + + template SetFilterReq m_setFilterReq (ProtocolFilter p_proto, IpAddress p_addr1, + IpAddress p_addr2, UInt16 p_port) :={ + protocol := p_proto, + interfaceInfos := { + { + IpInterfaceInfo := { + { + domainName := omit, + IpAddress := p_addr1, + portNumbers := { p_port } + }, + { + domainName := omit, + IpAddress := p_addr2, + portNumbers := { p_port } + } + } + } + } + } + + template SetFilterRsp m_setFilterRspAny := { + status := { + code := *, + reason := * + } + } + } // adapterTemplates + +}//end module + Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_CALL.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_CALL.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_CALL.ttcn (revision 18) @@ -0,0 +1,1824 @@ +/** + * @author STF 370 + * @version $Id: $ + * @desc This module provides ATS specific test case definitions. + */ +module AtsImsIot_TestCases_CALL { + import from AtsImsIot_Behavior { + function all; + } + + import from AtsImsIot_Functions { + function all; + } + + import from LibIot_PIXITS {modulepar PX_EUT_A, PX_EUT_B;} + + import from LibIms_UpperTester {type ImsUserInfo;} + + import from LibIot_TestConfiguration { + function f_cf_create_IotEquipmentUser; + } + + import from AtsImsIot_TestConfiguration { + const all; + function all; + } + + import from LibIot_TestInterface {type IotEquipmentUser;} + + import from AtsImsIot_TestSystem { + type ImsInterfaceMonitor, ImsTestCoordinator, IotSystemInterface; + } + + import from AtsImsIot_TestSystem {type CF_INT_CALL;} + + + /** + * @desc Default SIP URI with DNS/ENUM lookup procedure + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.1.1 + */ + testcase TC_IMS_CALL_0001() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B); + var ImsUserInfo v_userTelInfoB := f_getTelUserId(PX_EUT_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_call_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userTelInfoB); //Test Sequence Step 1 + + // check 1 (INVITE) + f_mtc_check_TP_IMS_5097_01_gm(v_gmA, true); // Check1 + f_mtc_check_TP_IMS_5097_02_gm(v_gmA, true); // Check2 + f_mtc_check_TP_IMS_5097_04_gm(v_gmA, false); // Check3 + f_mtc_check_TP_IMS_5097_01_ic(v_ic, true); // Check1 + f_mtc_check_TP_IMS_5097_02_ic(v_ic, true); // Check2 + f_mtc_check_TP_IMS_5097_04_ic(v_ic, false); // Check3 + + // checks 6, 10 (180 Ringing) + f_mtc_check_TP_IMS_5115_01_gm(v_gmB, true); // Check 6 + f_mtc_check_TP_IMS_5115_03_gm(v_gmB, true); // Check 7 + f_mtc_check_TP_IMS_5131_01_gm(v_gmB, false); // Check 10 + f_mtc_check_TP_IMS_5115_01_ic(v_ic, true); // Check 6 + f_mtc_check_TP_IMS_5115_03_ic(v_ic, true); // Check 7 + f_mtc_check_TP_IMS_5131_01_ic(v_ic, false); // Check 10 + + f_mtc_userCheckRinging(v_ueB); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA); //Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueB); //Test Sequence Step 4 + + // checks 8, 11 (2xx) + f_mtc_check_TP_IMS_5115_02_gm(v_gmB, true); // Check 8 + f_mtc_check_TP_IMS_5115_04_gm(v_gmB, true); // Check 9 + f_mtc_check_TP_IMS_5131_02_gm(v_gmB, false); // Check 11 + f_mtc_check_TP_IMS_5115_02_ic(v_ic, true); // Check 8 + f_mtc_check_TP_IMS_5115_04_ic(v_ic, true); // Check 9 + f_mtc_check_TP_IMS_5131_02_ic(v_ic, false); // Check 11 + + f_mtc_userCheckCallEstablished(v_ueA); //Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueB); //Test Sequence Step 6 + + //check 4 (ACK) + f_mtc_check_TP_IMS_5107_02_gm(v_gmA, false); // Check2 + f_mtc_check_TP_IMS_5107_02_ic(v_ic, false); // Check2 + + f_mtc_EndCall(v_ueA); //Test Sequence Step 7 + + // check 5 (BYE) + f_mtc_check_TP_IMS_5107_01_gm(v_gmA, false); // Check3 + f_mtc_check_TP_IMS_5107_01_ic(v_ic, false); // Check3 + + f_mtc_userCheckCallEnded(v_ueB); //Test Sequence Step 8 + f_mtc_userCheckCallEnded(v_ueA); //Test Sequence Step 9 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0001 + + + /** + * @desc Default SIP URI + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.1.2 + */ + testcase TC_IMS_CALL_0001F() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var IotEquipmentUser v_ueB2 := f_cf_create_IotEquipmentUser(c_userUE_B2); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_user_up(v_ueB2); + f_cf_int_call_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + f_mtc_userRegistration(v_ueB2, v_userInfoB); + + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 + + // check 1 (INVITE) + f_mtc_check_TP_IMS_5097_01_gm(v_gmA, false); // Check1 + f_mtc_check_TP_IMS_5097_01_ic(v_ic, false); // Check1 + + // checks 4, 6 (180 Ringing) + f_mtc_check_TP_IMS_5115_01_gm(v_gmB, true); // Check 4 + f_mtc_check_TP_IMS_5131_01_gm(v_gmB, false); // Check 6 + f_mtc_check_TP_IMS_5115_01_ic(v_ic, true); // Check4 + f_mtc_check_TP_IMS_5131_01_ic(v_ic, false); // Check6 + f_mtc_check_TP_IMS_5115_01_gm(v_gmB, true); // Check4 + f_mtc_check_TP_IMS_5131_01_gm(v_gmB, false); // Check6 + f_mtc_check_TP_IMS_5115_01_ic(v_ic, true); // Check4 from UE_B2 + f_mtc_check_TP_IMS_5131_01_ic(v_ic, false); // Check6 from UE_B2 + + f_mtc_userCheckRinging(v_ueB); //Test Sequence Step 2 + f_mtc_userCheckRinging(v_ueB2); //Test Sequence Step 3 + f_mtc_userCheckPeerIsRinging(v_ueA); //Test Sequence Step 4 + f_mtc_userAnswerCall(v_ueB2); //Test Sequence Step 5 + + // checks 5, 7 (2xx) + f_mtc_check_TP_IMS_5115_02_gm(v_gmB, true); // Check 5 + f_mtc_check_TP_IMS_5131_02_gm(v_gmB, false); // Check 7 + f_mtc_check_TP_IMS_5115_02_ic(v_ic, true); // Check 5 + f_mtc_check_TP_IMS_5131_02_ic(v_ic, false); // Check 7 + f_mtc_check_TP_IMS_5115_02_gm(v_gmB, true); // Check 5 + f_mtc_check_TP_IMS_5131_02_gm(v_gmB, false); // Check 7 + f_mtc_check_TP_IMS_5115_02_ic(v_ic, true); // Check5 from UE_B2 + f_mtc_check_TP_IMS_5131_02_ic(v_ic, false); // Check7 from UE_B2 + + + f_mtc_userCheckCallNoLongerOffered(v_ueB); //Test Sequence Step 6 + f_mtc_userCheckCallEstablished(v_ueA); //Test Sequence Step 7 + f_mtc_userCheckCallEstablished(v_ueB2); //Test Sequence Step 8 + + //check 2 (ACK) + f_mtc_check_TP_IMS_5107_02_gm(v_gmA, false); // Check2 + f_mtc_check_TP_IMS_5107_02_ic(v_ic, false); // Check2 + + f_mtc_EndCall(v_ueA); //Test Sequence Step 9 + + // check 3 (BYE) + f_mtc_check_TP_IMS_5107_01_gm(v_gmA, false); // Check3 + f_mtc_check_TP_IMS_5107_01_ic(v_ic, false); // Check3 + + f_mtc_userCheckCallEnded(v_ueB2 ); //Test Sequence Step 10 + f_mtc_userCheckCallEnded(v_ueA); //Test Sequence Step 11 + + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_PO_user_home_deregistration(v_ueB2); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_user_down(v_ueB2); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0001F + + + /** + * @desc Default Tel URI + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.1.3 + */ + testcase TC_IMS_CALL_0002() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getTelUserId(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getTelUserId(PX_EUT_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_call_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 + + // check 1 (INVITE) + f_mtc_check_TP_IMS_5097_01_gm(v_gmA, true); // Check1 + f_mtc_check_TP_IMS_5097_02_gm(v_gmA, false); // Check2 + f_mtc_check_TP_IMS_5097_01_ic(v_ic, true); // Check1 + f_mtc_check_TP_IMS_5097_02_ic(v_ic, false); // Check2 + + // checks 6, 10 (180 Ringing) + f_mtc_check_TP_IMS_5115_01_gm(v_gmB, true); // Check 5 + f_mtc_check_TP_IMS_5115_03_gm(v_gmB, true); // Check 6 + f_mtc_check_TP_IMS_5131_01_gm(v_gmB, false); // Check 9 + f_mtc_check_TP_IMS_5115_01_ic(v_ic, true); // Check 5 + f_mtc_check_TP_IMS_5115_03_ic(v_ic, true); // Check 6 + f_mtc_check_TP_IMS_5131_01_ic(v_ic, false); // Check 9 + + f_mtc_userCheckRinging(v_ueB); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA); //Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueB); //Test Sequence Step 4 + + // checks 8, 11 (2xx) + f_mtc_check_TP_IMS_5115_02_gm(v_gmB, true); // Check 7 + f_mtc_check_TP_IMS_5115_04_gm(v_gmB, true); // Check 8 + f_mtc_check_TP_IMS_5131_02_gm(v_gmB, false); // Check 10 + f_mtc_check_TP_IMS_5115_02_ic(v_ic, true); // Check 7 + f_mtc_check_TP_IMS_5115_04_ic(v_ic, true); // Check 8 + f_mtc_check_TP_IMS_5131_02_ic(v_ic, false); // Check 10 + + f_mtc_userCheckCallEstablished(v_ueA); //Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueB); //Test Sequence Step 6 + + //check 4 (ACK) + f_mtc_check_TP_IMS_5107_02_gm(v_gmA, false); // Check3 + f_mtc_check_TP_IMS_5107_02_ic(v_ic, false); // Check3 + + f_mtc_EndCall(v_ueA); //Test Sequence Step 7 + + // check 5 (BYE) + f_mtc_check_TP_IMS_5107_01_gm(v_gmA, false); // Check4 + f_mtc_check_TP_IMS_5107_01_ic(v_ic, false); // Check4 + + f_mtc_userCheckCallEnded(v_ueB); //Test Sequence Step 8 + f_mtc_userCheckCallEnded(v_ueA); //Test Sequence Step 9 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0002 + + + /** + * @desc Rejection of call from barred user + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.1.4 + */ + testcase TC_IMS_CALL_0003() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, omit}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_call_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 + + //check 1 (INVITE) + f_mtc_check_TP_IMS_5108_05_gm(v_gmA, false); // Check1 + f_mtc_check_TP_IMS_5108_05_ic(v_ic, false); // Check1 + + f_mtc_userCheckCallCannotBeEstablished(v_ueA); //Test Sequence Step 2 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0003 + + + /** + * @desc Rejection of call to non existing user + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.1.5 + */ + testcase TC_IMS_CALL_0004() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, omit}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_int_call_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + + // test body + v_userInfoB.privateId := ("non_existing_user"); + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 // + + //check 1 (INVITE) + f_mtc_check_TP_IMS_5132_01_gm(v_gmA, false); // Check1 + f_mtc_check_TP_IMS_5132_01_ic(v_ic, false); // Check1 + + f_mtc_userCheckCallCannotBeEstablished(v_ueA); //Test Sequence Step 2 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0004 + + + /** + * @desc Rejection of call to unavailable user + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.1.6 + */ + testcase TC_IMS_CALL_0005() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, omit}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_int_call_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + + // test body + v_userInfoB.privateId := ("unavailable"); + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 // + + //check 1 (INVITE) + f_mtc_check_TP_IMS_5133_01_gm(v_gmA, false); // Check1 + f_mtc_check_TP_IMS_5133_01_ic(v_ic, false); // Check1 + + f_mtc_userCheckCallCannotBeEstablished(v_ueA); //Test Sequence Step 2 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0005 + + + /** + * @desc Initial request to non-registered user with terminating unregistered filter criterion + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.1.7 + */ + testcase TC_IMS_CALL_0006() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, omit}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_int_call_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + + // test body + v_userInfoB.privateId := ("userNOAS_in_IMSB"); + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 // + + //check 1 (INVITE) + f_mtc_check_TP_IMS_5109_01_gm(v_gmA, false); // Check1 + f_mtc_check_TP_IMS_5109_01_ic(v_ic, false); // Check1 + + f_mtc_userCheckCallCannotBeEstablished(v_ueA); //Test Sequence Step 2 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0006 + + + /** + * @desc Normal call (roaming) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.2.1 + */ + testcase TC_IMS_CALL_0007() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + //var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_call_up(v_gmA, v_ic); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueB, v_userInfoA); //Test Sequence Step 1 + + // checks 1,2 gm + f_mtc_check_TP_IMS_5046_01_gm(v_gmA, true); // Check1 + f_mtc_check_TP_IMS_5067_01_gm(v_gmA, false); // Check2 + //checks 1,2 (INVITE from IMS_A to IMS_B) + f_mtc_check_TP_IMS_5046_01_ic(v_ic, true); // Check1 + f_mtc_check_TP_IMS_5067_01_ic(v_ic, false); // Check2 + + //checks 7,3 (INVITE from IMS_B to IMS_A and 100 Trying from IMS_A to IMS_B) + f_mtc_check_TP_IMS_5108_01_ic(v_ic, true); // Check7 + f_mtc_check_TP_IMS_5070_01_ic(v_ic, false); // Check3 + + // checks 5 (180 Ringing) + f_mtc_check_TP_IMS_5055_01_gm(v_gmA, true); // Check 5 + f_mtc_check_TP_IMS_5055_01_ic(v_ic, true); // Check 5 + + f_mtc_userCheckRinging(v_ueA); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueB); //Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueA); //Test Sequence Step 4 + + // checks 6 (2xx) + f_mtc_check_TP_IMS_5055_02_gm(v_gmA, true); // Check 6 + f_mtc_check_TP_IMS_5055_02_ic(v_ic, true); // Check 6 + + f_mtc_userCheckCallEstablished(v_ueB); //Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueA); //Test Sequence Step 6 + + f_mtc_EndCall(v_ueA); //Test Sequence Step 7 + + // check 4 (BYE) + //f_mtc_check_TP_IMS_5301_01_gm(v_gmA, false); // Check4 + //f_mtc_check_TP_IMS_5301_01_ic(v_ic, false); // Check4 + + f_mtc_userCheckCallEnded(v_ueB); //Test Sequence Step 8 + f_mtc_userCheckCallEnded(v_ueA); //Test Sequence Step 9 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_roam_call_down(v_gmA, v_ic); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0007 + + + /** + * @desc Normal call with hold/resume + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.2.2 + */ + testcase TC_IMS_CALL_0008() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_call_up(v_gmA, v_ic); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 + f_mtc_userCheckRinging(v_ueB); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA); //Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueB); //Test Sequence Step 4 + f_mtc_userCheckCallEstablished(v_ueA); //Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueB); //Test Sequence Step 6 + + f_mtc_userTriggerHold(v_ueA); //Test Sequence Step 7 + + // checks 3 and 1 (INVITE and 100 Trying) + f_mtc_check_TP_IMS_5120_01_gm(v_gmA, false, 1); // Check3 + f_mtc_check_TP_IMS_5081_01_ic(v_ic, true); // Check1 + f_mtc_check_TP_IMS_5120_01_ic(v_ic, false, 2); // Check3 + + //checks 2 (200 OK) + f_mtc_check_TP_IMS_5082_01_gm(v_gmA, false, 1); // Check2 + f_mtc_check_TP_IMS_5082_01_ic(v_ic, false, 2); // Check2 + + f_mtc_userCheckUserOnHold(v_ueB); //Test Sequence Step 8 + f_mtc_userCheckUserOnHold(v_ueA); //Test Sequence Step 9 + + f_mtc_userTriggerResume(v_ueA); //Test Sequence Step 10 + + // checks 3 and 1 (INVITE and 100 Trying) + f_mtc_check_TP_IMS_5120_01_gm(v_gmA, false, 0); // Check3 + f_mtc_check_TP_IMS_5120_01_ic(v_ic, true, 0); // Check3 + f_mtc_check_TP_IMS_5081_01_ic(v_ic, false); // Check1 + + //checks 2 (200 OK) + f_mtc_check_TP_IMS_5082_01_gm(v_gmA, false, 0); // Check2 + f_mtc_check_TP_IMS_5082_01_ic(v_ic, false, 0); // Check2 + + f_mtc_userCheckCallResumed(v_ueB); //Test Sequence Step 11 + f_mtc_userCheckCallResumed(v_ueA); //Test Sequence Step 12 + + f_mtc_EndCall(v_ueA); //Test Sequence Step 13 + + f_mtc_userCheckCallEnded(v_ueB); //Test Sequence Step 14 + f_mtc_userCheckCallEnded(v_ueA); //Test Sequence Step 15 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_roam_call_down(v_gmA, v_ic); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0008 + + + /** + * @desc Subsequent request(other than target refresh) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.2.3 + */ + testcase TC_IMS_CALL_0009() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_call_up(v_gmA, v_ic); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueB, v_userInfoA); //Test Sequence Step 1 + + f_mtc_userCheckRinging(v_ueA); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueB); //Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueA); //Test Sequence Step 4 + + f_mtc_userCheckCallEstablished(v_ueB); //Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueA); //Test Sequence Step 6 + + f_mtc_EndCall(v_ueB); //Test Sequence Step 7 + + // check 1 (BYE) + f_mtc_check_TP_IMS_5052_01_gm(v_gmA, false); // Check1 + f_mtc_check_TP_IMS_5052_01_ic(v_ic, false); // Check1 + + f_mtc_userCheckCallEnded(v_ueA); //Test Sequence Step 8 + f_mtc_userCheckCallEnded(v_ueB); //Test Sequence Step 9 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_roam_call_down(v_gmA, v_ic); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0009 + + + /** + * @desc Subsequent target refresh request(INVITE) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.2.4 + */ + testcase TC_IMS_CALL_0010() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_call_up(v_gmA, v_ic); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueB, v_userInfoA); //Test Sequence Step 1 + f_mtc_userCheckRinging(v_ueA); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueB); //Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueA); //Test Sequence Step 4 + f_mtc_userCheckCallEstablished(v_ueB); //Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueA); //Test Sequence Step 6 + + f_mtc_userTriggerHold(v_ueB); //Test Sequence Step 7 + + // checks 1 and 2 (INVITE) + f_mtc_check_TP_IMS_5048_01_gm(v_gmA, false, 1); // Check1 + f_mtc_check_TP_IMS_5048_01_ic(v_ic, true, 2); // Check1 + f_mtc_check_TP_IMS_5080_01_ic(v_ic, false); // Check2 + + f_mtc_userCheckUserOnHold(v_ueA); //Test Sequence Step 8 + f_mtc_userCheckUserOnHold(v_ueB); //Test Sequence Step 9 + + f_mtc_userTriggerResume(v_ueB); //Test Sequence Step 10 + + // checks 1 and 2 (INVITE) + f_mtc_check_TP_IMS_5048_01_gm(v_gmA, false, 0); // Check1 + f_mtc_check_TP_IMS_5048_01_ic(v_ic, true, 1); // Check1 + f_mtc_check_TP_IMS_5080_01_ic(v_ic, false); // Check2 + + f_mtc_userCheckCallResumed(v_ueA); //Test Sequence Step 11 + f_mtc_userCheckCallResumed(v_ueB); //Test Sequence Step 12 + + f_mtc_EndCall(v_ueA); //Test Sequence Step 13 + + f_mtc_userCheckCallEnded(v_ueB); //Test Sequence Step 14 + f_mtc_userCheckCallEnded(v_ueA); //Test Sequence Step 15 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_roam_call_down(v_gmA, v_ic); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0010 + + + /** + * @desc Call CANCEL due to loss of connectivity of calling user during call establishment + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.2.7 + */ + testcase TC_IMS_CALL_0013() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_call_up(v_gmA, v_ic); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueB, v_userInfoA); //Test Sequence Step 1 + f_mtc_userCheckRinging(v_ueA); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueB); //Test Sequence Step 3 + + f_cf_user_down(v_ueB);// //Test Sequence Step 4 --- UEB loses conectivity + + f_mtc_check_TP_IMS_5072_02_gm(v_gmA, false); // Check1 + + f_mtc_userCheckCallCancelled(v_ueA); //Test Sequence Step 5 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_cf_roam_call_down(v_gmA, v_ic); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0013 + + + /** + * @desc Call CANCEL by calling user + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.3.1 + */ + testcase TC_IMS_CALL_0014() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_call_up(v_gmA, v_ic); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 + f_mtc_userCheckRinging(v_ueB); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA); //Test Sequence Step 3 + f_mtc_userTriggerCancelCall (v_ueA); //Test Sequence Step 4 + + f_mtc_check_TP_IMS_5107_03_gm(v_gmA, false); // Check1 + f_mtc_check_TP_IMS_5107_03_ic(v_ic, false); // Check1 + + f_mtc_userCheckCallCancelled(v_ueB); //Test Sequence Step 5 + f_mtc_userCheckCallEnded(v_ueA); //Test Sequence Step 6 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_roam_call_down(v_gmA, v_ic); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0014 + + + /** + * @desc Call failure due to de-registration of calling user during call + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.3.3 + */ + testcase TC_IMS_CALL_0016() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var IotEquipmentUser v_imsA := f_cf_create_IotEquipmentUser("IMS A"); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, omit}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_user_up(v_imsA); + f_cf_int_call_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 + f_mtc_userCheckRinging(v_ueB); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA); //Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueB); //Test Sequence Step 4 + f_mtc_userCheckCallEstablished(v_ueA); //Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueB); //Test Sequence Step 6 + f_mtc_imsTriggerUeDeregistration(v_imsA, v_ueA); //Test Sequence Step 7 + + f_mtc_check_TP_IMS_5139_01_ic(v_ic, false); // Check 1 + + f_mtc_userCheckCallEnded(v_ueB); //Test Sequence Step 8 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_user_down(v_imsA); + f_cf_adapter_down(); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0016 + + + /** + * @desc Subsequent target refresh request (INVITE) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.3.4 + */ + testcase TC_IMS_CALL_0017() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + + // variables + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + + // configuration + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA,v_userInfoA); + f_PR_user_home_registration(v_ueB,v_userInfoB); + + // test body + + // Test Sequence 1 ---------------------> + f_mtc_userInitiateCall (v_ueA, v_userInfoB); + // Test Sequence 2 ---------------------> + f_mtc_userCheckRinging(v_ueB); + // Test Sequence 3 ---------------------> + f_mtc_userCheckPeerIsRinging(v_ueA); + // Test Sequence 4 ---------------------> + f_mtc_userAnswerCall(v_ueB); + // Test Sequence 5 ---------------------> + f_mtc_userCheckCallEstablished(v_ueA); + // Test Sequence 6 ---------------------> + f_mtc_userCheckCallEstablished(v_ueB); + // Test Sequence 7 ---------------------> + f_mtc_userTriggerHold(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_01_gm(v_gmA,1); + f_mtc_check_TP_IMS_5106_01_ic(v_ic,1); + + // Test Sequence 8 ---------------------> + f_mtc_userCheckUserOnHold(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,1); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,1); + + // Test Sequence 9 ---------------------> + f_mtc_userCheckUserOnHold(v_ueA); + // Test Sequence 10 --------------------> + f_mtc_userTriggerResume(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_01_gm(v_gmA,0); + f_mtc_check_TP_IMS_5106_01_ic(v_ic,0); + + // Test Sequence 11 --------------------> + f_mtc_userCheckCallResumed(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 12 --------------------> + f_mtc_userCheckCallResumed(v_ueA); + // Test Sequence 13 --------------------> + f_mtc_EndCall(v_ueA); + // Test Sequence 14 --------------------> + f_mtc_userCheckCallEnded(v_ueB ); + // Test Sequence 15 --------------------> + f_mtc_userCheckCallEnded(v_ueA); + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } + + + /** + * @desc Subsequent target refresh request (UPDATE) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.3.5 + */ + testcase TC_IMS_CALL_0018() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + + // variables + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + + // configuration + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA,v_userInfoA); + f_PR_user_home_registration(v_ueB,v_userInfoB); + + // test body + + // Test Sequence 1 ---------------------> + f_mtc_userInitiateCall (v_ueA, v_userInfoB); + // Test Sequence 2 ---------------------> + f_mtc_userCheckRinging(v_ueB); + // Test Sequence 3 ---------------------> + f_mtc_userCheckPeerIsRinging(v_ueA); + // Test Sequence 4 ---------------------> + f_mtc_userAnswerCall(v_ueB); + // Test Sequence 5 ---------------------> + f_mtc_userCheckCallEstablished(v_ueA); + // Test Sequence 6 ---------------------> + f_mtc_userCheckCallEstablished(v_ueB); + // Test Sequence 7 ---------------------> + f_mtc_userTriggerHold(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_02_gm(v_gmA); + f_mtc_check_TP_IMS_5106_02_ic(v_ic); + + // Test Sequence 8 ---------------------> + f_mtc_userCheckUserOnHold(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,1); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,1); + + // Test Sequence 9 ---------------------> + f_mtc_userCheckUserOnHold(v_ueA); + // Test Sequence 10 --------------------> + f_mtc_userTriggerResume(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_02_gm(v_gmA); + f_mtc_check_TP_IMS_5106_02_ic(v_ic); + + // Test Sequence 11 --------------------> + f_mtc_userCheckCallResumed(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 12 --------------------> + f_mtc_userCheckCallResumed(v_ueA); + // Test Sequence 13 --------------------> + f_mtc_EndCall(v_ueA); + // Test Sequence 14 --------------------> + f_mtc_userCheckCallEnded(v_ueB ); + // Test Sequence 15 --------------------> + f_mtc_userCheckCallEnded(v_ueA); + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } + + + /** + * @desc Addition of media streams (reINVITE) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.3.6 + */ + testcase TC_IMS_CALL_0019() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + + // variables + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + + // configuration + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA,v_userInfoA); + f_PR_user_home_registration(v_ueB,v_userInfoB); + + // test body + + // Test Sequence 1 ---------------------> + f_mtc_userInitiateCall (v_ueA, v_userInfoB); + // Test Sequence 2 ---------------------> + f_mtc_userCheckRinging(v_ueB); + // Test Sequence 3 ---------------------> + f_mtc_userCheckPeerIsRinging(v_ueA); + // Test Sequence 4 ---------------------> + f_mtc_userAnswerCall(v_ueB); + // Test Sequence 5 ---------------------> + f_mtc_userCheckCallEstablished(v_ueA); + // Test Sequence 6 ---------------------> + f_mtc_userCheckCallEstablished(v_ueB); + // Test Sequence 7 ---------------------> + f_mtc_userAddNewMediaStream(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_01_gm(v_gmA,1); + f_mtc_check_TP_IMS_5106_01_ic(v_ic,1); + + // Test Sequence 8 ---------------------> + // optional + // Test Sequence 9 ---------------------> + // optional + + // Test Sequence 10 --------------------> + f_mtc_userCheckNewMediaStream(v_ueB); + + // Test Sequence 11 --------------------> + f_mtc_userCheckNewMediaStream(v_ueA); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,1); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,1); + + // Test Sequence 12 --------------------> + f_mtc_EndCall(v_ueA); + // Test Sequence 13 --------------------> + f_mtc_userCheckCallEnded(v_ueB ); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 14 --------------------> + f_mtc_userCheckCallEnded(v_ueA ); + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } + + + /** + * @desc Addition of media streams (reINVITE) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.3.7 + */ + testcase TC_IMS_CALL_0020() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_A); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + + // variables + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + + // configuration + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA,v_userInfoA); + f_PR_user_home_registration(v_ueB,v_userInfoB); + + // test body + + // Test Sequence 1 ---------------------> + f_mtc_userInitiateCall (v_ueA, v_userInfoB); + // Test Sequence 2 ---------------------> + f_mtc_userCheckRinging(v_ueB); + // Test Sequence 3 ---------------------> + f_mtc_userCheckPeerIsRinging(v_ueA); + // Test Sequence 4 ---------------------> + f_mtc_userAnswerCall(v_ueB); + // Test Sequence 5 ---------------------> + f_mtc_userCheckCallEstablished(v_ueA); + // Test Sequence 6 ---------------------> + f_mtc_userCheckCallEstablished(v_ueB); + // Test Sequence 7 ---------------------> + f_mtc_userAddNewMediaStream(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_01_gm(v_gmA,1); + f_mtc_check_TP_IMS_5106_01_ic(v_ic,1); + + // Test Sequence 8 ---------------------> + // optional + // Test Sequence 9 ---------------------> + // optional + + // Test Sequence 10 --------------------> + f_mtc_userCheckNewMediaStream(v_ueB); + + // Test Sequence 11 --------------------> + f_mtc_userCheckNewMediaStream(v_ueA); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,1); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,1); + + // Test Sequence 12 --------------------> + f_mtc_userModifiyMediaStream(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_01_gm(v_gmA,0); + f_mtc_check_TP_IMS_5106_01_ic(v_ic,0); + + // Test Sequence 13 --------------------> + // optional + // Test Sequence 14 --------------------> + // optional + + // Test Sequence 15 --------------------> + f_mtc_userCheckNewMediaStream(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 16 --------------------> + f_mtc_userCheckNewMediaStream(v_ueA); + + // Test Sequence 17 --------------------> + f_mtc_EndCall(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 18 --------------------> + f_mtc_userCheckCallEnded(v_ueA ); + + // Test Sequence 19 --------------------> + f_mtc_userCheckCallEnded(v_ueB ); + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } + + + /** + * @desc Hold/resume media streams (reINVITE) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.3.8 + */ + testcase TC_IMS_CALL_0021() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_A); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + + // variables + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + + // configuration + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA,v_userInfoA); + f_PR_user_home_registration(v_ueB,v_userInfoB); + + // test body + + // Test Sequence 1 ---------------------> + f_mtc_userInitiateCall (v_ueA, v_userInfoB); + // Test Sequence 2 ---------------------> + f_mtc_userCheckRinging(v_ueB); + // Test Sequence 3 ---------------------> + f_mtc_userCheckPeerIsRinging(v_ueA); + // Test Sequence 4 ---------------------> + f_mtc_userAnswerCall(v_ueB); + // Test Sequence 5 ---------------------> + f_mtc_userCheckCallEstablished(v_ueA); + // Test Sequence 6 ---------------------> + f_mtc_userCheckCallEstablished(v_ueB); + // Test Sequence 7 ---------------------> + f_mtc_userAddNewMediaStream(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_01_gm(v_gmA,1); + f_mtc_check_TP_IMS_5106_01_ic(v_ic,1); + + // Test Sequence 8 ---------------------> + // optional + // Test Sequence 9 ---------------------> + // optional + + // Test Sequence 10 --------------------> + f_mtc_userCheckNewMediaStream(v_ueB); + + // Test Sequence 11 --------------------> + f_mtc_userCheckNewMediaStream(v_ueA); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,1); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,1); + + // Test Sequence 12 --------------------> + f_mtc_userTriggerHold(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_01_gm(v_gmA,0); + f_mtc_check_TP_IMS_5106_01_ic(v_ic,0); + + // Test Sequence 13 --------------------> + f_mtc_userCheckUserOnHold(v_ueA); + + // Test Sequence 14 --------------------> + f_mtc_userCheckUserOnHold(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 15 --------------------> + f_mtc_userTriggerResume(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_01_gm(v_gmA,0); + f_mtc_check_TP_IMS_5106_01_ic(v_ic,0); + + // Test Sequence 16 --------------------> + f_mtc_userCheckCallResumed(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 17 --------------------> + f_mtc_userCheckCallResumed(v_ueA); + + // Test Sequence 18 --------------------> + f_mtc_userRemoveMediaStream(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_01_gm(v_gmA,0); + f_mtc_check_TP_IMS_5106_01_ic(v_ic,0); + + // Test Sequence 19 --------------------> + f_mtc_userCheckRemoveMediaStream(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 20 --------------------> + // optional + + // Test Sequence 21 --------------------> + f_mtc_EndCall(v_ueB); + + // Test Sequence 22 --------------------> + f_mtc_userCheckCallEnded(v_ueA ); + + // Test Sequence 23 --------------------> + f_mtc_userCheckCallEnded(v_ueB ); + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } + + + /** + * @desc Hold/resume media streams (UPDATE) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.3.9 + */ + testcase TC_IMS_CALL_0022() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_A); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + + // variables + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + + // configuration + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA,v_userInfoA); + f_PR_user_home_registration(v_ueB,v_userInfoB); + + // test body + + // Test Sequence 1 ---------------------> + f_mtc_userInitiateCall (v_ueA, v_userInfoB); + // Test Sequence 2 ---------------------> + f_mtc_userCheckRinging(v_ueB); + // Test Sequence 3 ---------------------> + f_mtc_userCheckPeerIsRinging(v_ueA); + // Test Sequence 4 ---------------------> + f_mtc_userAnswerCall(v_ueB); + // Test Sequence 5 ---------------------> + f_mtc_userCheckCallEstablished(v_ueA); + // Test Sequence 6 ---------------------> + f_mtc_userCheckCallEstablished(v_ueB); + // Test Sequence 7 ---------------------> + f_mtc_userAddNewMediaStream(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_02_gm(v_gmA); + f_mtc_check_TP_IMS_5106_02_ic(v_ic); + + // Test Sequence 8 ---------------------> + // optional + // Test Sequence 9 ---------------------> + // optional + + // Test Sequence 10 --------------------> + f_mtc_userCheckNewMediaStream(v_ueB); + + // Test Sequence 11 --------------------> + f_mtc_userCheckNewMediaStream(v_ueA); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,1); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,1); + + // Test Sequence 12 --------------------> + f_mtc_userTriggerHold(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_02_gm(v_gmA); + f_mtc_check_TP_IMS_5106_02_ic(v_ic); + + // Test Sequence 13 --------------------> + f_mtc_userCheckUserOnHold(v_ueA); + + // Test Sequence 14 --------------------> + f_mtc_userCheckUserOnHold(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 15 --------------------> + f_mtc_userTriggerResume(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_02_gm(v_gmA); + f_mtc_check_TP_IMS_5106_02_ic(v_ic); + + // Test Sequence 16 --------------------> + f_mtc_userCheckCallResumed(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 17 --------------------> + f_mtc_userCheckCallResumed(v_ueA); + + // Test Sequence 18 --------------------> + f_mtc_userRemoveMediaStream(v_ueA); + + // check 1 + f_mtc_check_TP_IMS_5106_02_gm(v_gmA); + f_mtc_check_TP_IMS_5106_02_ic(v_ic); + + // Test Sequence 19 --------------------> + f_mtc_userCheckRemoveMediaStream(v_ueB); + + // check 2 + f_mtc_check_TP_IMS_5121_02_gm(v_gmB,0); + f_mtc_check_TP_IMS_5121_02_ic(v_ic,0); + + // Test Sequence 20 --------------------> + // optional + + // Test Sequence 21 --------------------> + f_mtc_EndCall(v_ueB); + + // Test Sequence 22 --------------------> + f_mtc_userCheckCallEnded(v_ueA ); + + // Test Sequence 23 --------------------> + f_mtc_userCheckCallEnded(v_ueB ); + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } + + + /** + * @desc Subsequent target refresh request (INVITE) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.4 + */ + testcase TC_IMS_CALL_0023() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + + // variables + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, omit}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + + // configuration + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA,v_userInfoA); + f_PR_user_home_registration(v_ueB,v_userInfoB); + + // test body + + // Test Sequence 1 ---------------------> + f_mtc_userInitiateCall (v_ueA, v_userInfoB); + // Test Sequence 2 ---------------------> + f_mtc_userCheckRinging(v_ueB); + // Test Sequence 3 ---------------------> + f_mtc_userCheckPeerIsRinging(v_ueA); + // Test Sequence 4 ---------------------> + f_mtc_userAnswerCall(v_ueB); + // Test Sequence 5 ---------------------> + f_mtc_userCheckCallEstablished(v_ueA); + // Test Sequence 6 ---------------------> + f_mtc_userCheckCallEstablished(v_ueB); + // Test Sequence 7 ---------------------> + f_mtc_userLooseConnection(v_ueB); + + // check 1 + f_mtc_check_TP_IMS_5074_01_ic(v_ic); + + // Test Sequence 8 ---------------------> + f_mtc_userCheckCallEnded(v_ueA); + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + f_cf_adapter_down(); + } + + + /** + * @desc Normal call - TH(Topology hiding) + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.5.1 + */ + testcase TC_IMS_CALL_0024() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_call_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 + + //check 1,2,3,6 (INVITE and 100Trying) + f_mtc_check_TP_IMS_5135_01_gm(v_gmA, true); // Check1 - INVITE + f_mtc_check_TP_IMS_5404_01_gm(v_gmA, false); // Check3 - INVITE + f_mtc_check_TP_IMS_5135_01_ic(v_ic, true); // Check1 - INVITE + f_mtc_check_TP_IMS_5137_01_ic(v_ic, true); // Check2 - INVITE + f_mtc_check_TP_IMS_5404_01_ic(v_ic, true); // Check3 - INVITE + f_mtc_check_TP_IMS_5414_01_ic(v_ic, false); // Check6 - INVITE and 100Trying + + //check 7 (180 Ringing) + + f_mtc_check_TP_IMS_5137_02_gm(v_gmB, false); // Check 7 + f_mtc_check_TP_IMS_5137_02_ic(v_ic, false); // Check 7 + + f_mtc_userCheckRinging(v_ueB); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA); //Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueB); //Test Sequence Step 4 + + //check 8 (2xx) + + f_mtc_check_TP_IMS_5137_03_gm(v_gmB, false); // Check 8 + f_mtc_check_TP_IMS_5137_03_ic(v_ic, false); // Check 8 + + f_mtc_userCheckCallEstablished(v_ueA); //Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueB); //Test Sequence Step 6 + + // check 4 (ACK) + f_mtc_check_TP_IMS_5408_01_gm(v_gmA, false); // Check4 + f_mtc_check_TP_IMS_5408_01_ic(v_ic, false); // Check4 + + f_mtc_EndCall(v_ueA); //Test Sequence Step 7 + + // check 5 (BYE) + f_mtc_check_TP_IMS_5408_03_gm(v_gmA, false); // Check4 + f_mtc_check_TP_IMS_5408_03_ic(v_ic, false); // Check4 + + //check 8 (2xx) + + f_mtc_check_TP_IMS_5137_03_gm(v_gmB, false); // Check 8 + f_mtc_check_TP_IMS_5137_03_ic(v_ic, false); // Check 8 + + f_mtc_userCheckCallEnded(v_ueB); //Test Sequence Step 8 + f_mtc_userCheckCallEnded(v_ueA); //Test Sequence Step 9 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_int_call_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0024 + + /** + * @desc CANCEL call by calling user + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.5.2 + */ + testcase TC_IMS_CALL_0025() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_call_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 + f_mtc_userCheckRinging(v_ueB); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA); //Test Sequence Step 3 + f_mtc_userTriggerCancelCall (v_ueA); //Test Sequence Step 4 + + f_mtc_check_TP_IMS_5408_02_gm(v_gmA, false); // Check1 + f_mtc_check_TP_IMS_5408_02_ic(v_ic, false); // Check1 + + f_mtc_userCheckCallCancelled(v_ueB); //Test Sequence Step 5 + f_mtc_userCheckCallTerminated(v_ueA); //Test Sequence Step 6 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_int_call_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_CALL_0025 + + + /** + * @desc Normal call with hold/resume - roaming + * @see TS 186 011-2 V2.3.1 cause 4.5.3.1.5.3 + */ + testcase TC_IMS_CALL_0026() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_userInfoA := f_getSipUserId(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getSipUserId(PX_EUT_B); + + // map/connect component ports + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_call_up(v_gmA, v_ic); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB); //Test Sequence Step 1 + f_mtc_userCheckRinging(v_ueB); //Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA); //Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueB); //Test Sequence Step 4 + f_mtc_userCheckCallEstablished(v_ueA); //Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueB); //Test Sequence Step 6 + + f_mtc_userTriggerHold(v_ueA); //Test Sequence Step 7 + + // check 1 (INVITE) + f_mtc_check_TP_IMS_5408_04_gm(v_gmA, false,1); // Check1 + f_mtc_check_TP_IMS_5408_04_ic(v_ic, false,2); // Check1 + + f_mtc_userCheckUserOnHold(v_ueB); //Test Sequence Step 8 + f_mtc_userCheckUserOnHold(v_ueA); //Test Sequence Step 9 + + f_mtc_userTriggerResume(v_ueA); //Test Sequence Step 10 + + // check 1 (INVITE) + f_mtc_check_TP_IMS_5408_04_gm(v_gmA, false,0); // Check1 + f_mtc_check_TP_IMS_5408_04_ic(v_ic, false,1); // Check1 + + f_mtc_userCheckCallResumed(v_ueB); //Test Sequence Step 11 + f_mtc_userCheckCallResumed(v_ueA); //Test Sequence Step 12 + + f_mtc_EndCall(v_ueA); //Test Sequence Step 13 + + f_mtc_userCheckCallEnded(v_ueB); //Test Sequence Step 14 + f_mtc_userCheckCallEnded(v_ueA); //Test Sequence Step 15 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_roam_call_down(v_gmA, v_ic); + } //end testcase TC_IMS_CALL_0026 + +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_MESS.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_MESS.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_MESS.ttcn (revision 18) @@ -0,0 +1,355 @@ +/** + * @author STF 370 + * @version $Id: $ + * @desc This module provides ATS specific test case definitions. + */ +module AtsImsIot_TestCases_MESS { + + import from AtsImsIot_Behavior {function all;} + + import from AtsImsIot_Functions {function all;} + + import from LibCommon_VerdictControl {type FncRetCode;} + + import from LibIot_PIXITS {modulepar PX_EUT_A, PX_EUT_B;} + + import from LibIms_UpperTester {type ImsUserInfo;} + + import from LibIot_TestConfiguration { + function f_cf_create_IotEquipmentUser; + } + + import from AtsImsIot_TestConfiguration { + const all; + function all; + } + + import from LibIot_TestInterface {type IotEquipmentUser;} + + import from AtsImsIot_TestSystem { + type ImsInterfaceMonitor, ImsTestCoordinator, IotSystemInterface; + } + + import from AtsImsIot_TestSystem {type CF_INT_CALL;} + + import from AtsImsIot_Templates all; + + + /** + * @desc + * IMS network shall support SIP messages greater than 1500 bytes. + * (in ETSI TS 186 011-2 V2.3.1 cause 4.5.1.1) + */ + testcase TC_IMS_MESS_0001() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var CF_INT_CALL v_config := {v_gmA, v_ic, omit}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + + // preamble + f_cf_int_call_up(v_config); + f_PR_user_home_registration(v_ueA, f_getAnyValidUser(PX_EUT_A)); + f_PR_user_home_registration(v_ueB, f_getAnyValidUser(PX_EUT_B)); + log("**** TC_IMS_MESS_0001: Preamble done. ****"); + + // test body + f_mtc_userSendMessage(v_ueA, f_getMessageBody(1301)); + f_mtc_check_TP_IMS_4002_01_gm(v_gmA); + f_mtc_check_TP_IMS_4002_01_ic(v_ic); + f_mtc_userCheckMessageReceipt(v_ueB); + + // postabmle + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + log("**** TC_IMS_MESS_0001: Postamble done. ****"); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + } + + + + /** + * @desc + * IMS network handles messaging with SIP identity correctly without + * topology hiding. (ETSI TS 186 011-2 V2.3.1 cause 4.5.4.1) + */ + testcase TC_IMS_MESS_0002() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA, f_getSipUserId(PX_EUT_A)); + f_PR_user_home_registration(v_ueB, f_getAnyValidUser(PX_EUT_B)); + + // test body + f_mtc_userSendMessage(v_ueA, "test"); + + f_mtc_check_TP_IMS_5097_05_gm(v_gmA, false); // message not removed from port queue + //f_mtc_check_TP_IMS_5097_07_gm(v_gmA, false); // message removed from port queue + f_mtc_check_TP_IMS_5097_05_ic(v_ic, false);// message not removed from port queue + //f_mtc_check_TP_IMS_5097_07_ic(v_ic, false);// message removed from port queue + + f_mtc_userCheckMessageReceipt(v_ueB); + + f_mtc_check_TP_IMS_5117_02_gm(v_gmB, true);// message not removed from port queue + f_mtc_check_TP_IMS_5118_01_gm(v_gmB, false);// message removed from port queue + f_mtc_check_TP_IMS_5117_02_ic(v_ic, true);// message not removed from port queue + f_mtc_check_TP_IMS_5118_01_ic(v_ic, false);// message removed from port queue + + // postabmle + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + } + + + /** + * @desc + * IMS network handles messaging with TEL URI identities correctly + * (ETSI TS 186 011-2 V2.3.1 cause 4.5.4.2) + */ + testcase TC_IMS_MESS_0003() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA, f_getTelUserId(PX_EUT_A)); + f_PR_user_home_registration(v_ueB, f_getTelUserId(PX_EUT_B)); + + // test body + f_mtc_userSendMessage(v_ueA, "test"); + + f_mtc_check_TP_IMS_5097_07_gm(v_gmA, false); + f_mtc_check_TP_IMS_5097_07_ic(v_ic, false); + + f_mtc_userCheckMessageReceipt(v_ueB); + + f_mtc_check_TP_IMS_5117_02_gm(v_gmB, true);// message not removed from port queue + f_mtc_check_TP_IMS_5118_01_gm(v_gmB, true);// message not removed from port queue + f_mtc_check_TP_IMS_5117_06_gm(v_gmB, false);// message removed from port queue + f_mtc_check_TP_IMS_5117_02_ic(v_ic, true);// message not removed from port queue + f_mtc_check_TP_IMS_5118_01_ic(v_ic, true);// message not removed from port queue + f_mtc_check_TP_IMS_5117_06_ic(v_ic, false);// message removed from port queue + + // postabmle + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + } + + /** + * @desc + * IMS network handles messaging with DNS/ENUM lookup procedure correctly + * (ETSI TS 186 011-2 V2.3.1 cause 4.5.4.3) + */ + testcase TC_IMS_MESS_0004() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var CF_INT_CALL v_config := {v_gmA, v_ic, v_gmB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA, f_getTelUserId(PX_EUT_A)); + f_PR_user_home_registration(v_ueB, f_getTelUserId(PX_EUT_B)); + + // test body + f_mtc_userSendMessage(v_ueA, "test"); + + f_mtc_check_TP_IMS_5097_08_gm(v_gmA, false); + f_mtc_check_TP_IMS_5097_08_ic(v_ic, false); + + // TODO add DNS checks + + f_mtc_userCheckMessageReceipt(v_ueB); + + f_mtc_check_TP_IMS_5117_06_gm(v_gmB, false); + f_mtc_check_TP_IMS_5117_06_ic(v_ic, false); + + // postabmle + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + } + + + + /** + * @desc + * IMS network handles messaging while roaming correctly. + * (ETSI TS 186 011-2 V2.3.1 cause 4.5.4.4) + */ + testcase TC_IMS_MESS_0005() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_call_up(v_gmA, v_ic); + + // preamble + f_PR_user_home_registration(v_ueA, f_getAnyValidUser(PX_EUT_A)); + f_PR_user_roaming_registration(v_ueB, f_getAnyValidUser(PX_EUT_B)); + + // test body + f_mtc_userSendMessage(v_ueA, "test"); + + f_mtc_check_TP_IMS_5108_02_ic(v_ic); // TODO must be checked + + f_mtc_userCheckMessageReceipt(v_ueB); + + f_mtc_check_TP_IMS_5118_01_gm(v_gmA, false); + f_mtc_check_TP_IMS_5118_01_ic(v_ic, false); + + // postabmle + f_PO_user_home_deregistration(v_ueA); + f_PO_user_roaming_deregistration(v_ueB); + f_cf_roam_call_down(v_gmA, v_ic); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + } + + /** + * @desc + * IMS network handles messaging correctly when receiving user is nit registered. + * (ETSI TS 186 011-2 V2.3.1 cause 4.5.4.5) + */ + testcase TC_IMS_MESS_0006() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var CF_INT_CALL v_config := {v_gmA, v_ic, omit}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA, f_getAnyValidUser(PX_EUT_A)); + + // test body + f_mtc_userSendMessage(v_ueA, "test"); + + f_mtc_check_TP_IMS_5114_02_gm(v_gmA); + f_mtc_check_TP_IMS_5114_02_ic(v_ic); + + f_mtc_userCheckMessageNotDelivered(v_ueA); + + // postabmle + f_PO_user_home_deregistration(v_ueA); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_adapter_down(); + } + + + /** + * @desc + * IMS network handles messaging correctly when receiving user is nit registered. + * (ETSI TS 186 011-2 V2.3.1 cause 4.5.4.6) + */ + testcase TC_IMS_MESS_0007() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var CF_INT_CALL v_config := {v_gmA, v_ic, omit}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_call_up(v_config); + + // preamble + f_PR_user_home_registration(v_ueA, f_getAnyValidUser(PX_EUT_A)); + f_PR_user_home_registration(v_ueB, f_getAnyValidUser(PX_EUT_B)); + + // test body + f_mtc_userSendMessage(v_ueA, "test"); + + f_mtc_check_TP_IMS_5108_06_gm(v_gmA); + f_mtc_check_TP_IMS_5108_06_ic(v_ic); + + f_mtc_userCheckMessageNotDelivered(v_ueA); + + // postabmle + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_cf_int_call_down(v_config); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + } +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_REG.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_REG.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_REG.ttcn (revision 18) @@ -0,0 +1,379 @@ +/** + * @author STF 370 + * @version $Id: $ + * @desc This module provides ATS specific test case definitions. + */ +module AtsImsIot_TestCases_REG { + + import from AtsImsIot_Behavior { + function all; + } + + import from AtsImsIot_Functions { + function all; + } + + import from LibIot_PIXITS {modulepar PX_EUT_A, PX_EUT_B;} + + import from LibIms_UpperTester {type ImsUserInfo;} + + import from LibIot_TestConfiguration { + function f_cf_create_IotEquipmentUser; + } + + import from AtsImsIot_TestConfiguration { + const all; + function all; + } + + import from LibIot_TestInterface {type IotEquipmentUser;} + + import from AtsImsIot_TestSystem { + type ImsInterfaceMonitor, ImsTestCoordinator, IotSystemInterface; + } + + import from LibSip_SIPTypesAndValues all; + + + + /** + * @desc + * First time registration in a visited IMS network. + * (in ETSI TS 186 011-2 V2.3.1 cause 4.5.2.1) + */ + testcase TC_IMS_REG_0001() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_anyValidUser := f_getAnyValidUser(PX_EUT_B); + var Response v_200OK_Step8; + var Request v_Subscribe_Step10; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueB); + f_cf_roam_reg_up(v_gmA, v_ic); + + // test body + f_mtc_userRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 1 @TODO shouldn't this be EUT_A? + + // @TODO check mw_credentialIntegrityNo, mw_credentialIntegrityYes + + f_mtc_check_TP_IMS_5011_01_gm(v_gmA, true); // Check1 when + f_mtc_check_TP_IMS_5011_01_ic(v_ic, true); // Check1 then + + f_mtc_check_TP_IMS_5089_01_gm_when(v_gmA, false); // Check4 when (Gm) + f_mtc_check_TP_IMS_5089_01_ic_when(v_ic, false); // Check4 when (Mw) + f_mtc_check_TP_IMS_5089_01_ic_then(v_ic, false); // Check4 then @TODO check mw_WwwAuthenticate + + f_mtc_check_TP_IMS_5011_02_gm(v_gmA, true); // Check2 when (Gm) + f_mtc_check_TP_IMS_5011_02_ic(v_ic, true); // Check2 then (Mw) + + f_mtc_check_TP_IMS_5092_01_gm(v_gmA, false); // Check5 when (Gm) + f_mtc_check_TP_IMS_5092_01_ic_when(v_ic, false); // Check5 when (Mw) + f_mtc_check_TP_IMS_5092_01_ic(v_ic, true); // Check5 then + + v_200OK_Step8 := f_mtc_check_TP_IMS_5044_01_ic_when(v_ic, false); // Check3 when + f_mtc_check_TP_IMS_5044_01_ic(v_ic, v_200OK_Step8, true); // Check3 then + + v_Subscribe_Step10 := f_mtc_check_TP_IMS_5096_01_ic_when(v_ic, false); // Check6 when + f_mtc_check_TP_IMS_5096_01_ic(v_ic, v_Subscribe_Step10, false); // Check6 then + + // Test Sequence Step 2 + f_mtc_userCheckRegistration(v_ueB, v_anyValidUser); + + // postamble + f_PO_user_home_deregistration(v_ueB); + + // unmap/disconnect component ports + f_cf_user_down(v_ueB); + f_cf_roam_reg_down(v_gmA, v_ic); + f_cf_adapter_down(); + } + + /** + * @desc + * No response from first entry point on REGISTER with topology hiding + * (TS 186 011-2 V2.3.1 cause 4.5.2.2) + */ + // @TODO + testcase TC_IMS_REG_0002() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var Request v_Register_Step4; // why do we need this variable? + var Response v_200OK_Step9; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueB); + f_cf_roam_reg_up(v_gmA, v_ic); + + // test body + f_mtc_userRegistration(v_ueB, f_getAnyValidUser(PX_EUT_A)); // Test Sequence Step 1 + + // check no response (check1-when) -message skip (1st register) + // check included in check1-then + + // check mw for second register request + f_mtc_check_TP_IMS_5203_01_ic(v_ic); // (Check1-then) + + // check gm for protected register (Check2-when) + + // check mw for protected register (check2-when) + + // check mw for 200_response (check2-then) + //v_200OK_Step9 := f_mtc_check_TP_IMS_5092_01_ic(v_ic); // Check2 + + //Step 2 + f_mtc_userCheckRegistration(v_ueB, f_getAnyValidUser(PX_EUT_B)); + + // postamble + f_PO_user_home_deregistration(v_ueB); + + // unmap/disconnect component ports + f_cf_user_down(v_ueB); + f_cf_roam_reg_down(v_gmA, v_ic); + f_cf_adapter_down(); + } + + /** + * @desc + * 403 response from first entry point on REGISTER with topology hiding + * (ETSI TS 186 011-2 V2.3.1 cause 4.5.2.3) + */ + // @TODO + testcase TC_IMS_REG_0002H() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var Request v_Register_Step4; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueB); + f_cf_roam_reg_up(v_gmA, v_ic); + + // test body + f_mtc_userRegistration(v_ueB, f_getAnyValidUser(PX_EUT_A)); + + f_mtc_check_TP_IMS_5402_01_gm(v_gmA); + + v_Register_Step4 := f_mtc_check_TP_IMS_5402_01_ic(v_ic); // Check1 + + f_mtc_userCheckRegistration(v_ueB, f_getAnyValidUser(PX_EUT_B)); + + // postamble + f_PO_user_home_deregistration(v_ueB); + + // unmap/disconnect component ports + f_cf_user_down(v_ueB); + f_cf_roam_reg_down(v_gmA, v_ic); + } + /** + * @desc + * 403 response to REGISTER from an un-trusted domain without topology hiding + * (ETSI TS 186 011-2 V2.3.1 cause 4.5.2.4) + */ + testcase TC_IMS_REG_0003() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_anyValidUser := f_getAnyValidUser(PX_EUT_B); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueB); + f_cf_roam_reg_up(v_gmA, v_ic); + + // test body + f_mtc_userRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 1 + + f_mtc_check_TP_IMS_5129_01_gm(v_gmA, false); // Check1 when (Gm) + f_mtc_check_TP_IMS_5129_01_ic_when(v_ic, false); // Check1 when (Mw) + + f_mtc_check_TP_IMS_5129_01_ic(v_ic, false); // Check1 then + + f_mtc_userCheckNoRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 2 - unsuccessful registration + + // unmap/disconnect component ports + f_cf_user_down(v_ueB); + f_cf_roam_reg_down(v_gmA, v_ic); + } + + /** + * @desc + * 403 response to REGISTER from an un-trusted domain with topology hiding + * (ETSI TS 186 011-2 V2.3.1 cause 4.5.2.5) + */ + testcase TC_IMS_REG_0003H() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_anyValidUser := f_getAnyValidUser(PX_EUT_B); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueB); + f_cf_roam_reg_up(v_gmA, v_ic); + + // test body + f_mtc_userRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 1 + + f_mtc_check_TP_IMS_5411_01_gm(v_gmA, false); // Check1 when (Gm) + f_mtc_check_TP_IMS_5411_01_ic_when(v_gmA, false); //Check1 when (Mw) + + f_mtc_check_TP_IMS_5411_01_ic(v_ic, false); // Check1 then + + f_mtc_userCheckNoRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 2 - unsuccessful registration + + // unmap/disconnect component ports + f_cf_user_down(v_ueB); + f_cf_roam_reg_down(v_gmA, v_ic); + } + + /** + * @desc IMS network supports network initiated re-registration + * upon receipt of a new registration with new contact information + * @see ETSI TS 186 011-2 V2.3.1 cause 4.5.2.6 + */ + testcase TC_IMS_REG_0004() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_anyValidUser := f_getAnyValidUser(PX_EUT_B); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueB); + f_cf_roam_reg_up(v_gmA, v_ic); + + // test body + f_mtc_userRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 1 + + f_mtc_check_TP_IMS_5088_01_gm(v_gmA, false); // Check1 when (REGISTER) + f_mtc_check_TP_IMS_5088_01_ic(v_ic, false); // Check1 then (NOTIFY) + + f_mtc_userCheckRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 2 + + // postamble + f_PO_user_home_deregistration(v_ueB); + + // unmap/disconnect component ports + f_cf_user_down(v_ueB); + f_cf_roam_reg_down(v_gmA, v_ic); + } + + /** + * @desc IMS network can initiate user de-registration, + * e.g., when a user runs out of credit + * @see ETSI TS 186 011-2 V2.3.1 cause 4.5.2.7 + */ + testcase TC_IMS_REG_0005() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_anyValidUser := f_getAnyValidUser(PX_EUT_B); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueB); + f_cf_roam_reg_up(v_gmA, v_ic); + + // test body + // IMS_B is triggered manually to de-register user B // Test Sequence Step 1 manuallz + + // IMS_B receives a network_originated_deregistration_event // Check1 when manually + + f_mtc_check_TP_IMS_5093_01_UE_ic(v_ic, v_anyValidUser, false); // check1 then - 1st NOTIFY + f_mtc_check_TP_IMS_5093_01_IMS_ic(v_ic, false); // check1 then - 2nd NOTIFY + + f_mtc_userCheckNoRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 2 - check that user is not registered anymore (de-registration) + + // postamble + f_PO_user_home_deregistration(v_ueB); + + // unmap/disconnect component ports + f_cf_user_down(v_ueB); + f_cf_roam_reg_down(v_gmA, v_ic); + } + /** + * @desc IMS network can initiate user re-authentication + * @see ETSI TS 186 011-2 V2.3.1 cause 4.5.2.8 + */ + testcase TC_IMS_REG_0006() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_anyValidUser := f_getAnyValidUser(PX_EUT_B); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueB); + f_cf_roam_reg_up(v_gmA, v_ic); + + // test body + + //IMS_B receives a network_originated_deregistration_event // Check1 when manually + + f_mtc_check_TP_IMS_5094_01_UE(v_ic, v_anyValidUser, false); // check1 then - 1st NOTIFY + f_mtc_check_TP_IMS_5094_01_IMS(v_ic, false); // check1 then - 2nd NOTIFY + + f_mtc_userCheckRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 2 + + // postamble + f_PO_user_home_deregistration(v_ueB); + f_cf_roam_reg_down(v_gmA, v_ic); + + // unmap/disconnect component ports + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + } + + /** + * @desc + * First time registration in a visited IMS network with topology hiding. + * (ETSI TS 186 011-2 V2.3.1 cause 4.5.2.9) + */ + // @TODO + testcase TC_IMS_REG_0007() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsUserInfo v_anyValidUser := f_getAnyValidUser(PX_EUT_B); + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueB); + f_cf_roam_reg_up(v_gmA, v_ic); + + // test body + + f_mtc_userRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 1 + + f_mtc_check_TP_IMS_5134_01_gm(v_gmA, false); // Check1 when + f_mtc_check_TP_IMS_5134_01_ic(v_ic, false); // Check1 then + + f_mtc_check_TP_IMS_5405_01_gm(v_gmA, false); // Check2 when + f_mtc_check_TP_IMS_5405_01_ic(v_ic, false); // Check2 then // @TODO mdw_TP_IMS_5405_01_ic needs to be checked + + f_mtc_userCheckRegistration(v_ueB, v_anyValidUser); // Test Sequence Step 2 + + // postamble + f_PO_user_home_deregistration(v_ueB); + f_cf_roam_reg_down(v_gmA, v_ic); + + // unmap/disconnect component ports + f_cf_user_down(v_ueB); + f_cf_adapter_down(); + } +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_SS.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_SS.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestCases_SS.ttcn (revision 18) @@ -0,0 +1,680 @@ +/** + * @author STF 370 + * @version $Id: $ + * @desc This module provides ATS specific test case definitions. + */ +module AtsImsIot_TestCases_SS { + + import from AtsImsIot_Behavior { + function all; + } + + import from AtsImsIot_Functions { + function all; + } + + import from LibIot_PIXITS {modulepar PX_EUT_A, PX_EUT_B;} + + import from LibIms_UpperTester {type ImsUserInfo;} + + import from LibIot_TestConfiguration { + function f_cf_create_IotEquipmentUser; + } + + import from AtsImsIot_TestConfiguration { + const all; + function all; + } + + import from LibIot_TestInterface {type IotEquipmentUser;} + + import from AtsImsIot_TestSystem { + type ImsInterfaceMonitor, ImsTestCoordinator, IotSystemInterface, CF_INT_AS, CF_ROAM_AS; + } + + /** + * @desc Supplementary Service HOLD with AS + * @see TS 186 011-2 V2.3.1 cause 4.5.5.1 + */ + testcase TC_IMS_SS_0001() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_iscB := f_cf_create_monitor(c_isc_B); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getHoldUser(PX_EUT_B); + var CF_INT_AS v_config := {v_gmA, v_ic, v_gmB, omit, v_iscB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_as_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_StartAllTrafficCapture(); + f_mtc_userInitiateCall (v_ueA, v_userInfoB);//Test Sequence Step 1 + + f_mtc_userCheckRinging(v_ueB);//Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA);//Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueB);//Test Sequence Step 4 + f_mtc_userCheckCallEstablished(v_ueA);//Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueB);//Test Sequence Step 6 + + f_mtc_userTriggerHold(v_ueB);//Test Sequence Step 7 + + //check 1 - INVITE(hold) + f_mtc_check_TP_IMS_5310_01_gm(v_gmB, 0); // Check1 + f_mtc_check_TP_IMS_5310_01_isc(v_iscB); // Check1 + + f_mtc_userCheckUserOnHold(v_ueA);//Test Sequence Step 8 + + //check 2 - 200 OK + f_mtc_check_TP_IMS_5312_01_ic(v_ic, 1); // Check2 + f_mtc_check_TP_IMS_5312_01_isc(v_iscB); // Check2 + + f_mtc_userCheckUserOnHold(v_ueB);//Test Sequence Step 9 + + f_mtc_userTriggerResume(v_ueB);//Test Sequence Step 10 + + //check 3 - INVITE(resume) + f_mtc_check_TP_IMS_5310_01_gm(v_gmB, 0); // Check3 + f_mtc_check_TP_IMS_5310_01_isc(v_iscB); // Check3 + + f_mtc_userCheckCallResumed(v_ueA);//Test Sequence Step 11 + + //check 4 - 200 OK + f_mtc_check_TP_IMS_5312_01_ic(v_ic, 0); // Check4 + f_mtc_check_TP_IMS_5312_01_isc(v_iscB); // Check4 + + f_mtc_userCheckCallResumed(v_ueB);//Test Sequence Step 12 + f_mtc_EndCall(v_ueA);//Test Sequence Step 13 + f_mtc_userCheckCallEnded(v_ueB );//Test Sequence Step 14 + f_mtc_userCheckCallEnded(v_ueA);//Test Sequence Step 15 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_int_as_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_SS_0001 + + /** + * @desc Supplementary Service HOLD with AS in roaming + * @see TS 186 011-2 V2.3.1 cause 4.5.5.2 + */ + testcase TC_IMS_SS_0002() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_iscB := f_cf_create_monitor(c_isc_B); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getHoldUser(PX_EUT_B); + var CF_ROAM_AS v_config := {v_gmA, v_ic, v_gmB, omit, v_iscB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_as_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_StartAllTrafficCapture(); + f_mtc_userInitiateCall (v_ueA, v_userInfoB);//Test Sequence Step 1 + + f_mtc_userCheckRinging(v_ueB);//Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA);//Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueB);//Test Sequence Step 4 + f_mtc_userCheckCallEstablished(v_ueA);//Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueB);//Test Sequence Step 6 + + f_mtc_userTriggerHold(v_ueB);//Test Sequence Step 7 + + //check 1 - INVITE(hold) + f_mtc_check_TP_IMS_5310_01_gm(v_gmB, 1); // Check1 - skip one INVITE when call is established + f_mtc_check_TP_IMS_5310_01_isc(v_iscB); // Check1 + + f_mtc_userCheckUserOnHold(v_ueA);//Test Sequence Step 8 + + //check 2 - 200 OK + f_mtc_check_TP_IMS_5312_01_ic(v_ic, 2); // Check2 - skip two 200OK when call is established - because roaming + f_mtc_check_TP_IMS_5312_01_isc(v_iscB); // Check2 + + f_mtc_userCheckUserOnHold(v_ueB);//Test Sequence Step 9 + f_mtc_userTriggerResume(v_ueB);//Test Sequence Step 10 + + //check 3 - INVITE(resume) + f_mtc_check_TP_IMS_5310_01_gm(v_gmB, 0); // Check3 + f_mtc_check_TP_IMS_5310_01_isc(v_iscB); // Check3 + + f_mtc_userCheckCallResumed(v_ueA);//Test Sequence Step 11 + + //check 4 - 200 OK + f_mtc_check_TP_IMS_5312_01_ic(v_ic, 1); // Check4 + f_mtc_check_TP_IMS_5312_01_isc(v_iscB); // Check4 + + f_mtc_userCheckCallResumed(v_ueB);//Test Sequence Step 12 + f_mtc_EndCall(v_ueA);//Test Sequence Step 13 + f_mtc_userCheckCallEnded(v_ueB );//Test Sequence Step 14 + f_mtc_userCheckCallEnded(v_ueA);//Test Sequence Step 15 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_roam_as_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_SS_0002 + + /** + * @desc Supplementary Service OIP with AS + * @see TS 186 011-2 V2.3.1 cause 4.5.5.3 + */ + testcase TC_IMS_SS_0003() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_iscB := f_cf_create_monitor(c_isc_B); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getOIPUser(PX_EUT_B); + var CF_INT_AS v_config := {v_gmA, v_ic, v_gmB, omit, v_iscB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_as_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_StartAllTrafficCapture(); + f_mtc_userInitiateCall (v_ueA, v_userInfoB);//Test Sequence Step 1 + + //check 1,2 - INVITE + f_mtc_check_TP_IMS_5097_02_gm(v_gmA, false);// Check1 + f_mtc_check_TP_IMS_5097_02_ic(v_ic, true);// Check1 + f_mtc_check_TP_IMS_5108_03_ic(v_ic, false);// Check2 + f_mtc_check_TP_IMS_5108_03_isc(v_iscB, false);// Check2 + + f_mtc_userCheckRinging(v_ueB);//Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA);//Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueB);//Test Sequence Step 4 + + //check 3 - 200 OK + f_mtc_check_TP_IMS_5115_08_isc(v_iscB, false);// Check3 + f_mtc_check_TP_IMS_5115_08_ic(v_ic, false, 0);// Check3 + + f_mtc_userCheckCallEstablished(v_ueA);//Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueB);//Test Sequence Step 6 + + f_mtc_EndCall(v_ueA);//Test Sequence Step 7 + f_mtc_userCheckCallEnded(v_ueB);//Test Sequence Step 8 + f_mtc_userCheckCallEnded(v_ueA);//Test Sequence Step 9 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_int_as_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_SS_0003 + + /** + * @desc Supplementary Service OIP with AS in roaming + * @see TS 186 011-2 V2.3.1 cause 4.5.5.4 + */ + testcase TC_IMS_SS_0004() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_iscB := f_cf_create_monitor(c_isc_B); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getOIPUser(PX_EUT_B); + var CF_ROAM_AS v_config := {v_gmA, v_ic, v_gmB, omit, v_iscB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_as_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_StartAllTrafficCapture(); + f_mtc_userInitiateCall (v_ueA, v_userInfoB);//Test Sequence Step 1 + + //checks 1,2 - INVITE + f_mtc_check_TP_IMS_5097_02_gm(v_gmA, false);// Check1 + f_mtc_check_TP_IMS_5097_02_ic(v_ic, true);// Check1 + f_mtc_check_TP_IMS_5108_03_ic(v_ic, false);// Check2 + f_mtc_check_TP_IMS_5108_03_isc(v_iscB, false);// Check2 + + f_mtc_userCheckRinging(v_ueB);//Test Sequence Step 2 + f_mtc_userCheckPeerIsRinging(v_ueA);//Test Sequence Step 3 + f_mtc_userAnswerCall(v_ueB);//Test Sequence Step 4 + + //check 3 - 200 OK + f_mtc_check_TP_IMS_5115_08_isc(v_iscB, false);// Check3 + f_mtc_check_TP_IMS_5115_08_ic(v_ic, false, 1);// Check3 //skip 200OK IMSA->IMSB + + f_mtc_userCheckCallEstablished(v_ueA);//Test Sequence Step 5 + f_mtc_userCheckCallEstablished(v_ueB);//Test Sequence Step 6 + + f_mtc_EndCall(v_ueA);//Test Sequence Step 7 + f_mtc_userCheckCallEnded(v_ueB);//Test Sequence Step 8 + f_mtc_userCheckCallEnded(v_ueA);//Test Sequence Step 9 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_roam_as_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_SS_0004 + + /** + * @desc Supplementary Service OIR and ACR with AS + * @see TS 186 011-2 V2.3.1 cause 4.5.5.5 + */ + testcase TC_IMS_SS_0005() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_iscA := f_cf_create_monitor(c_isc_A); + var ImsInterfaceMonitor v_iscB := f_cf_create_monitor(c_isc_B); + var ImsUserInfo v_userInfoA := f_getOIRUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getACRUser(PX_EUT_B); + var CF_INT_AS v_config := {v_gmA, v_ic, v_gmB, v_iscA, v_iscB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_as_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_StartAllTrafficCapture(); + f_mtc_userInitiateCall (v_ueA, v_userInfoB);//Test Sequence Step 1 + + //check 1 - INVITE + f_mtc_check_TP_IMS_5108_03_ic(v_ic, false);// Check1 + f_mtc_check_TP_IMS_5108_03_isc(v_iscB, false);// Check1 + + //check 2 - 433 Anonymity Disallowe + f_mtc_check_TP_IMS_5313_01_ic(v_ic, false);// Check2 + f_mtc_check_TP_IMS_5313_01_isc(v_iscA, false);// Check2 + + f_mtc_userCheckCallRejectedACR(v_ueA);//Test Sequence Step 2 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_int_as_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_SS_0005 + + /** + * @desc Supplementary Service OIR and ACR with AS in roaming + * @see TS 186 011-2 V2.3.1 cause 4.5.5.6 + */ + testcase TC_IMS_SS_0006() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_iscA := f_cf_create_monitor(c_isc_A); + var ImsInterfaceMonitor v_iscB := f_cf_create_monitor(c_isc_B); + var ImsUserInfo v_userInfoA := f_getACRUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getOIRUser(PX_EUT_B); + var CF_ROAM_AS v_config := {v_gmA, v_ic, v_gmB, v_iscA, v_iscB}; + + // map/connect component ports + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_as_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_StartAllTrafficCapture(); + f_mtc_userInitiateCall (v_ueB, v_userInfoA);//Test Sequence Step 1 + + //checks 1,2,3 - INVITE + f_mtc_check_TP_IMS_5046_01_gm(v_gmB, true);// Check1 + f_mtc_check_TP_IMS_5067_01_gm(v_gmB, false);// Check2 + f_mtc_check_TP_IMS_5046_01_ic(v_ic, true);// Check1 + f_mtc_check_TP_IMS_5067_01_ic(v_ic, true);// Check2 + f_mtc_check_TP_IMS_5097_09_ic(v_ic, false);// Check3 + f_mtc_check_TP_IMS_5097_09_isc(v_iscB, false);// Check3 + + f_mtc_userCheckCallRejectedACR(v_ueB);//Test Sequence Step 2 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_roam_as_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_SS_0006 + + /** + * @desc Supplementary Service CFU with AS + * @see TS 186 011-2 V2.3.1 cause 4.5.5.7 + */ + testcase TC_IMS_SS_0007() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var IotEquipmentUser v_ueB2 := f_cf_create_IotEquipmentUser(c_userUE_B2); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_iscB := f_cf_create_monitor(c_isc_B); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + var ImsUserInfo v_userInfoB2 := f_getAnyValidUser(PX_EUT_B);//// TODO f_getAnyValidUser2 ? + var CF_INT_AS v_config := {v_gmA, v_ic, v_gmB, omit, v_iscB}; + + // map/connect component ports + // f_cf_user_up(v_ueB); + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_user_up(v_ueB2); + f_cf_int_as_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + f_mtc_userRegistration(v_ueB2, v_userInfoB2); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB);//Test Sequence Step 1 + + // checks 1,2 - INVITE + f_mtc_check_TP_IMS_5097_01_gm(v_gmA, false); // Check1 + f_mtc_check_TP_IMS_5097_01_ic(v_ic, true); // Check1 + f_mtc_check_TP_IMS_5108_03_ic(v_ic, false); // Check2 + f_mtc_check_TP_IMS_5108_03_isc(v_iscB, false); // Check2 + + //f_mtc_userCheckRinging(v_ueB2); //possible Test Sequence Step + //f_mtc_userCheckPeerIsRinging(v_ueA); //possible Test Sequence Step + f_mtc_userAnswerCall(v_ueB2);//Test Sequence Step 3 + + //check 3 - 200 OK + f_mtc_check_TP_IMS_5115_08_isc(v_iscB, false);// Check3 + f_mtc_check_TP_IMS_5115_08_ic(v_ic, false, 0);// Check3 + + f_mtc_userCheckCallEstablished(v_ueA);//Test Sequence Step 4 + f_mtc_userCheckCallEstablished(v_ueB2);//Test Sequence Step 5 + + f_mtc_EndCall(v_ueA);//Test Sequence Step 6 + f_mtc_userCheckCallEnded(v_ueB2);//Test Sequence Step 7 + f_mtc_userCheckCallEnded(v_ueA);//Test Sequence Step 8 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_PO_user_home_deregistration(v_ueB2); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_user_down(v_ueB2); + f_cf_int_as_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_SS_0007 + + /** + * @desc Supplementary Service CFU with AS in roaming + * @see TS 186 011-2 V2.3.1 cause 4.5.5.8 + */ + testcase TC_IMS_SS_0008() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var IotEquipmentUser v_ueA2 := f_cf_create_IotEquipmentUser(c_userUE_A2); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_iscA := f_cf_create_monitor(c_isc_A); + var ImsUserInfo v_userInfoA := f_getAnyValidUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getAnyValidUser(PX_EUT_B); + var ImsUserInfo v_userInfoA2 := f_getAnyValidUser(PX_EUT_A);//// TODO f_getAnyValidUser2 ? + var CF_ROAM_AS v_config := {v_gmA, v_ic, v_gmB, v_iscA, omit}; + + // map/connect component ports + // f_cf_user_up(v_ueB); + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_user_up(v_ueA2); + f_cf_roam_as_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + f_mtc_userRegistration(v_ueA2, v_userInfoA2); + + // test body + f_mtc_userInitiateCall (v_ueB, v_userInfoA);//Test Sequence Step 1 + + // checks 1,2,3 - INVITE + f_mtc_check_TP_IMS_5046_01_gm(v_gmB, true); // Check1 + f_mtc_check_TP_IMS_5067_01_gm(v_gmB, false); // Check2 + f_mtc_check_TP_IMS_5046_01_ic(v_ic, true); // Check1 + f_mtc_check_TP_IMS_5067_01_ic(v_ic, true); // Check2 + f_mtc_check_TP_IMS_5070_01_ic(v_ic, false); // Check3 + + //f_mtc_userCheckRinging(v_ueA2); //possible Test Sequence Step + //f_mtc_userCheckPeerIsRinging(v_ueA); //possible Test Sequence Step + f_mtc_userAnswerCall(v_ueA2);//Test Sequence Step 3 + + //check 4 - 200 OK + f_mtc_check_TP_IMS_5110_01_isc(v_iscA); // Check4 + f_mtc_check_TP_IMS_5110_01_ic(v_ic); // Check4 + + f_mtc_userCheckCallEstablished(v_ueB);//Test Sequence Step 4 + f_mtc_userCheckCallEstablished(v_ueA2);//Test Sequence Step 5 + + f_mtc_EndCall(v_ueB);//Test Sequence Step 6 + f_mtc_userCheckCallEnded(v_ueA2);//Test Sequence Step 7 + f_mtc_userCheckCallEnded(v_ueB);//Test Sequence Step 8 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + f_PO_user_home_deregistration(v_ueA2); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_user_down(v_ueA2); + f_cf_roam_as_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_SS_0008 + + /** + * @desc Supplementary Service OIP and OIR with AS + * @see TS 186 011-2 V2.3.1 cause 4.5.5.9 + */ + testcase TC_IMS_SS_0009() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_iscA := f_cf_create_monitor(c_isc_A); + var ImsInterfaceMonitor v_iscB := f_cf_create_monitor(c_isc_B); + var ImsUserInfo v_userInfoA := f_getOIRUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getOIPUser(PX_EUT_B); + var CF_INT_AS v_config := {v_gmA, v_ic, v_gmB, v_iscA, v_iscB}; + + // map/connect component ports + // f_cf_user_up(v_ueB); + f_cf_adapter_up(); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_int_as_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueA, v_userInfoB);//Test Sequence Step 1 + + // checks 1,2 - INVITE + f_mtc_check_TP_IMS_5097_01_gm(v_gmA, false); // Check1 + f_mtc_check_TP_IMS_5097_01_ic(v_ic, true); // Check1 + f_mtc_check_TP_IMS_5108_03_ic(v_ic, false); // Check2 + f_mtc_check_TP_IMS_5108_03_isc(v_iscB, false); // Check2 + + f_mtc_userCheckRinging(v_ueB); //possible Test Sequence Step + f_mtc_userCheckPeerIsRinging(v_ueA); //possible Test Sequence Step + f_mtc_userAnswerCall(v_ueB);//Test Sequence Step 3 + + f_mtc_userCheckCallEstablished(v_ueA);//Test Sequence Step 4 + f_mtc_userCheckCallEstablished(v_ueB);//Test Sequence Step 5 + + f_mtc_EndCall(v_ueB);//Test Sequence Step 6 + f_mtc_userCheckCallEnded(v_ueA);//Test Sequence Step 7 + f_mtc_userCheckCallEnded(v_ueB);//Test Sequence Step 8 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_int_as_down(v_config); + f_cf_adapter_down(); + } //end testcase TC_IMS_SS_0009 + + /** + * @desc Supplementary Service OIP and OIR with AS in roaming + * @see TS 186 011-2 V2.3.1 cause 4.5.5.10 + */ + testcase TC_IMS_SS_0010() runs on ImsTestCoordinator system IotSystemInterface { + // create components + var IotEquipmentUser v_ueA := f_cf_create_IotEquipmentUser(c_userUE_A); + var IotEquipmentUser v_ueB := f_cf_create_IotEquipmentUser(c_userUE_B); + var ImsInterfaceMonitor v_gmA := f_cf_create_monitor(c_gm_A); + var ImsInterfaceMonitor v_gmB := f_cf_create_monitor(c_gm_B); + var ImsInterfaceMonitor v_ic := f_cf_create_monitor(c_ic); + var ImsInterfaceMonitor v_iscA := f_cf_create_monitor(c_isc_A); + var ImsInterfaceMonitor v_iscB := f_cf_create_monitor(c_isc_B); + var ImsUserInfo v_userInfoA := f_getOIRUser(PX_EUT_A); + var ImsUserInfo v_userInfoB := f_getOIPUser(PX_EUT_B); + var CF_ROAM_AS v_config := {v_gmA, v_ic, v_gmB, v_iscA, v_iscB}; + + // map/connect component ports + // f_cf_user_up(v_ueB); + f_cf_user_up(v_ueA); + f_cf_user_up(v_ueB); + f_cf_roam_as_up(v_config); + + // preamble + f_mtc_userRegistration(v_ueA, v_userInfoA); + f_mtc_userRegistration(v_ueB, v_userInfoB); + + // test body + f_mtc_userInitiateCall (v_ueB, v_userInfoA);//Test Sequence Step 1 + + //checks 1,2,5 - INVITE + f_mtc_check_TP_IMS_5046_01_gm(v_gmB, true);// Check1 + f_mtc_check_TP_IMS_5067_01_gm(v_gmB, false);// Check5 + f_mtc_check_TP_IMS_5046_01_ic(v_ic, true);// Check1 + f_mtc_check_TP_IMS_5067_01_ic(v_ic, true);// Check5 + f_mtc_check_TP_IMS_5097_09_ic(v_ic, false);// Check2 + f_mtc_check_TP_IMS_5097_09_isc(v_iscB, false);// Check2 + + //check 3 -180 Ringing + f_mtc_check_TP_IMS_5308_01_gm(v_gmA, false);// Check3 + f_mtc_check_TP_IMS_5308_01_isc(v_iscA, false);// Check3 + + f_mtc_userCheckRinging(v_ueB); //possible Test Sequence Step + f_mtc_userCheckPeerIsRinging(v_ueA); //possible Test Sequence Step + f_mtc_userAnswerCall(v_ueA);//Test Sequence Step 3 + + //check 4 -200 OK + f_mtc_check_TP_IMS_5308_02_gm(v_gmA, false);// Check4 + f_mtc_check_TP_IMS_5308_02_isc(v_iscA, false);// Check4 + + f_mtc_userCheckCallEstablished(v_ueB);//Test Sequence Step 4 + f_mtc_userCheckCallEstablished(v_ueA);//Test Sequence Step 5 + + f_mtc_EndCall(v_ueB);//Test Sequence Step 6 + f_mtc_userCheckCallEnded(v_ueA);//Test Sequence Step 7 + f_mtc_userCheckCallEnded(v_ueB);//Test Sequence Step 8 + + // postamble + f_PO_user_home_deregistration(v_ueA); + f_PO_user_home_deregistration(v_ueB); + + //unmap/disconnet component ports + f_cf_user_down(v_ueA); + f_cf_user_down(v_ueB); + f_cf_roam_as_down(v_config); + } //end testcase TC_IMS_SS_0010 +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestConfiguration.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestConfiguration.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestConfiguration.ttcn (revision 18) @@ -0,0 +1,1002 @@ +/* + * @author STF 370 + * @version $Id $ + * @desc This module contains functions which implement the + * configuration of the SUT adapter and mapping of test + * components for establishing and tearing down different + * test configurations. + */ + +module AtsImsIot_TestConfiguration { + + import from LibIms_UpperTester language "TTCN-3:2008 Amendment 1" { + modulepar PX_IMS_USER_DATA; + } + + import from LibIot_TypesAndValues { + type StartTrafficCaptureRsp, StopTrafficCaptureRsp; + } + + import from AtsImsIot_TestSystem {type CF_INT_CALL, CF_INT_AS, CF_ROAM_AS;} + + import from LibIot_PIXITS { + modulepar PX_EUT_A, PX_EUT_B, PX_PRODUCTS, PX_MAX_MSG_WAIT; + } + + import from LibIot_Functions language "TTCN-3:2008 Amendment 1" { + altstep a_receiveIOTVerdict; + function f_setConformanceVerdict, f_setE2EVerdict; + } + + import from AtsImsIot_Templates { + template + m_generalConfigurationReq_offline, + m_generalConfigurationReq_online, + m_generalConfigurationReq_merge, + m_generalConfigurationRsp_success, + m_generalConfigurationRsp_error, + m_generalConfigurationRsp_timeout, + m_SetFilterReq, + mw_SetFilterRsp, + m_startTrafficCaptureReq, + m_stopTrafficCaptureReq, + m_startTrafficCaptureRsp_any, + m_stopTrafficCaptureRsp_any; + } + + import from LibCommon_VerdictControl {type FncRetCode;} + + import from LibIot_TypesAndValues { + type + InterfaceInfo, + InterfaceInfoList, + Product, + ProtocolFilter, + StartTrafficCaptureRsp, + StopTrafficCaptureRsp, + SetFilterReq, + SetFilterRsp, + Status; + } + + import from LibIot_TestConfiguration { + function f_cf_oracle_up, f_cf_oracle_down; + } + + import from AtsImsIot_TestSystem { + type ImsInterfaceMonitor, ImsTestCoordinator; + } + + import from LibIot_TestInterface {type IotEquipmentUser;} + + import from AtsImsIot_Functions {function f_setInterfaceNameOnComponent;} + + + group constantDefinitions { + //* interface monitor name Gm A + const charstring c_gm_A := "Gm A"; + //* interface monitor name Gm B + const charstring c_gm_B := "Gm B"; + //* interface monitor name Mx A + const charstring c_mx_A := "Mx A"; + //* interface monitor name Mx B + const charstring c_mx_B := "Mx B"; + //* interface monitor name Ic + const charstring c_ic := "Ic"; + //* interface monitor name Isc A + const charstring c_isc_A := "Isc A"; + //* interface monitor name Isc B + const charstring c_isc_B := "Isc B"; + //* eut trigger name User A + const charstring c_trigger_A := "User A"; + //* eut trigger name User B + const charstring c_trigger_B := "User B"; + //* eut trigger name User A + const charstring c_userUE_A := "User A"; + const charstring c_userUE_A2 := "User A2"; + //* eut trigger name User B + const charstring c_userUE_B := "User B"; + const charstring c_userUE_B2 := "User B2"; + } + + group mappingFunctions { + + /** + * + * @desc initialize the adapter port of MTC + */ + function f_cf_adapter_up() runs on ImsTestCoordinator { + map(self:acPort, system:acPort); + } + + /** + * + * @desc uninitialize the adapter port of MTC + */ + function f_cf_adapter_down() runs on ImsTestCoordinator { + unmap(self:acPort, system:acPort); + } + + /** + * + * @desc initialize trigger component ports + * @param p_driver trigger component + */ + function f_cf_user_up(in IotEquipmentUser p_driver) runs on ImsTestCoordinator { + // connect sync ports + connect(p_driver:syncPort, self:syncPort); + // connect TSI ports + map(p_driver:eaPort, system:eaPort); + // configure oracle + f_cf_oracle_up(p_driver); + } + + /** + * + * @desc uninitialize trigger component ports + * @param p_driver trigger component + */ + function f_cf_user_down(in IotEquipmentUser p_driver) runs on ImsTestCoordinator { + // disconnect sync ports + disconnect(p_driver:syncPort, self:syncPort); + // disconnect TSI ports + unmap(p_driver:eaPort, system:eaPort); + // release oracle ports + f_cf_oracle_down(p_driver); + } + + /** + * @desc configures monitor component: connects to the synchronnization + * port, maps to the TSI port and connects to the oracle + * @param p_monitor monitor component + */ + function f_cf_monitor_up(in ImsInterfaceMonitor p_monitor) runs on ImsTestCoordinator { + // connect sync ports + connect(p_monitor:syncPort, self:syncPort); + connect(p_monitor:icpPort, self:icpPort); + // mapp TSI port + map(p_monitor:dPort, system:dPort); + map(p_monitor:acPort, system:acPort); + // configure oracle + f_cf_oracle_up(p_monitor); + } + + /** + * @desc frees monitor component: disconnects the synchronnization + * port, unmaps from the TSI port and disconnects from the oracle + * @param p_monitor monitor component + */ + function f_cf_monitor_down(in ImsInterfaceMonitor p_monitor) runs on ImsTestCoordinator { + // connect sync ports + disconnect(p_monitor:syncPort, self:syncPort); + disconnect(p_monitor:icpPort, self:icpPort); + // mapp TSI port + unmap(p_monitor:dPort, system:dPort); + unmap(p_monitor:acPort, system:acPort); + // configure oracle + f_cf_oracle_down(p_monitor); + } + + } + + group adapterConfiguration { + + function f_cf_setFilter(in SetFilterReq p_req) runs on ImsInterfaceMonitor { + var SetFilterRsp v_rsp; + var template Status v_status := { + code := e_success, + reason := * + } + + tc_wait.start; + acPort.send(p_req); + alt { + [] acPort.receive (mw_SetFilterRsp(v_status)) -> value v_rsp { + tc_wait.stop; + f_setE2EVerdict(pass, "Adapter Configuration: setting monitor filter successful"); + f_setConformanceVerdict(pass, "Adapter Configuration: setting monitor filter successful"); + } + [] acPort.receive (mw_SetFilterRsp(?)) -> value v_rsp { + tc_wait.stop; + f_setE2EVerdict(inconc, "Adapter Configuration: error while setting monitor filter"); + f_setConformanceVerdict(inconc, "Adapter Configuration: error while setting monitor filter"); + } + [] tc_wait.timeout { + f_setE2EVerdict(inconc, "Adapter Configuration: timer expires while waiting for response"); + f_setConformanceVerdict(inconc, "Adapter Configuration: timer expires while waiting for response"); + } + } + } + + + } + + group componentCreation { + + /** + * @desc creates a monitor component + * @param p_name name of the monitor component + * @return the created monitor component + */ + function f_cf_create_monitor(in charstring p_name) runs on ImsTestCoordinator return ImsInterfaceMonitor { + var ImsInterfaceMonitor v_monitor := ImsInterfaceMonitor.create(p_name) alive; + v_monitor.start(f_setInterfaceNameOnComponent(p_name)); + v_monitor.done; + return v_monitor; + } + } + + + group testConfiguration { + + /** + * @desc + * Test configuration function for roaming registration szenario. + * More information can be found in ETSI TS 186 011-2 V2.3.1 Cause + * 4.3.4. + * @param p_Gm Gm interface monitor component + * @param p_ic Mw interface monitor component + */ + function f_cf_roam_reg_up( + inout ImsInterfaceMonitor p_Gm, + inout ImsInterfaceMonitor p_ic + ) runs on ImsTestCoordinator { + // Initialize the Adapter (including the TrafficCapture process). + timer tc_configureGuard; + var StartTrafficCaptureRsp startResult; + activate(a_receiveIOTVerdict()); + + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_generalConfigurationReq_offline); + alt { + [] acPort.receive (m_generalConfigurationRsp_success) { + log("General configuration succeed."); + tc_configureGuard.stop; + } + [] acPort.receive (m_generalConfigurationRsp_timeout) { + setverdict(fail); + tc_configureGuard.stop; + stop; + } + [] acPort.receive (m_generalConfigurationRsp_error) { + setverdict(fail); + tc_configureGuard.stop; + stop; + } + [] acPort.receive { + log("Unknown response."); + tc_configureGuard.stop; + setverdict (inconc); + stop; + } + [] tc_configureGuard.timeout { + log("Timeout."); + setverdict (inconc); + stop; + } + } + + f_cf_monitor_up(p_Gm); + f_cf_monitor_up(p_ic); + + // TODO UE IP address and port is missing + p_Gm.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + f_getInterfaceInfoList("Gm", PX_EUT_A, PX_EUT_B) + ) + ))); + p_Gm.done; + + p_ic.start(f_cf_setFilter( + valueof(m_SetFilterReq( + e_sip, + f_getInterfaceInfoList("Ic", PX_EUT_A, PX_EUT_B) + ) + ))); + p_ic.done; + + // Start traffic capture processing. + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_startTrafficCaptureReq); + alt { + [] acPort.receive (m_startTrafficCaptureRsp_any) -> value startResult { + tc_configureGuard.stop; + if (startResult.status.code != e_success) + { + log("**** StartTrafficCaptureReq unsuccessfull! ****"); + setverdict(fail); + stop; + } + } + [] tc_configureGuard.timeout { + log("**** StartTrafficCaptureReq not answered. ****"); + setverdict (inconc); + stop; + } + } + } + + /** + * @desc + * Test configuration function for roaming registration szenario. + * More information can be found in ETSI TS 186 011-2 V2.3.1 Cause + * 4.3.4. + * @param p_Gm Gm interface monitor component + * @param p_ic Mw interface monitor component + */ + function f_cf_roam_reg_down( + inout ImsInterfaceMonitor p_Gm, + inout ImsInterfaceMonitor p_ic + ) runs on ImsTestCoordinator { + // Stop traffic capture processing. + timer tc_configureGuard; + var StopTrafficCaptureRsp stopResult; + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_stopTrafficCaptureReq); + alt { + [] acPort.receive (m_stopTrafficCaptureRsp_any) -> value stopResult { + tc_configureGuard.stop; + if (stopResult.status.code != e_success) + { + log("**** TC_IMS_MESS_0001: StopTrafficCaptureReq unsuccessfull! ****"); + setverdict(fail); + } + } + [] tc_configureGuard.timeout { + log("**** TC_IMS_MESS_0001: StopTrafficCaptureReq not answered. ****"); + setverdict (inconc); + } + } + f_cf_monitor_down(p_Gm); + f_cf_monitor_down(p_ic); + } + + /** + * @desc + * Interworking Call test configuration. Mapps/connects all related + * ports and initialize the test adapter. + * More information can be found in ETSI TS 186 011-2 V2.3.1 Cause + * 4.3.4. + * @param p_GmA Gm A Interface Monitor component + * @param p_ic Mw Interface Monitor component + * @param p_GmB + * Gm B Interface Monitor component (optional, can be omitted) + */ + function f_cf_int_call_up( + inout CF_INT_CALL p_config + ) runs on ImsTestCoordinator { + // Initialize the Adapter (including the TrafficCapture process). + timer tc_configureGuard; + var StartTrafficCaptureRsp startResult; + + activate(a_receiveIOTVerdict()); + + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_generalConfigurationReq_offline); + alt { + [] acPort.receive (m_generalConfigurationRsp_success) { + log("General configuration succeed."); + tc_configureGuard.stop; + } + [] acPort.receive (m_generalConfigurationRsp_timeout) { + setverdict(fail); + tc_configureGuard.stop; + stop; + } + [] acPort.receive (m_generalConfigurationRsp_error) { + setverdict(fail); + tc_configureGuard.stop; + stop; + } + [] acPort.receive { + log("Unknown response."); + tc_configureGuard.stop; + setverdict (inconc); + stop; + } + [] tc_configureGuard.timeout { + log("Timeout."); + setverdict (inconc); + stop; + } + } + + f_cf_monitor_up(p_config.gmA); + f_cf_monitor_up(p_config.mw); + if(isvalue(p_config.gmB)) { + f_cf_monitor_up(p_config.gmB); + } + + // TODO UE IP address and port is missing + p_config.gmA.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + {f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_A])} + ) + ))); + p_config.gmA.done; + + p_config.mw.start(f_cf_setFilter( + valueof(m_SetFilterReq( + e_sip, + f_getInterfaceInfoList("Ic", PX_EUT_A, PX_EUT_B) + ) + ))); + p_config.mw.done; + + if(isvalue(p_config.gmB)) { + p_config.gmB.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + {f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_B])} + ) + ))); + p_config.gmB.done; + } + // Start traffic capture processing. + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_startTrafficCaptureReq); + alt { + [] acPort.receive (m_startTrafficCaptureRsp_any) -> value startResult { + tc_configureGuard.stop; + if (startResult.status.code != e_success) + { + log("**** StartTrafficCaptureReq unsuccessfull! ****"); + setverdict(fail); + stop; + } + } + [] tc_configureGuard.timeout { + log("**** StartTrafficCaptureReq not answered. ****"); + setverdict (inconc); + stop; + } + } + } + + /** + * @desc + * Interworking Call test configuration. Ummaps/disconnect the + * related component ports. More information can be found in ETSI TS + * 186 011-2 V2.3.1 Cause 4.3.4. + * @param p_GmA Gm A Interface Monitor component + * @param p_ic Mw Interface Monitor component + * @param p_GmB + * Gm B Interface Monitor component (optional, can be omitted) + */ + function f_cf_int_call_down( + inout CF_INT_CALL p_config + ) runs on ImsTestCoordinator { + // Stop traffic capture processing. + timer tc_configureGuard; + var StopTrafficCaptureRsp stopResult; + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_stopTrafficCaptureReq); + alt { + [] acPort.receive (m_stopTrafficCaptureRsp_any) -> value stopResult { + tc_configureGuard.stop; + if (stopResult.status.code != e_success) + { + log("**** TC_IMS_MESS_0001: StopTrafficCaptureReq unsuccessfull! ****"); + setverdict(fail); + } + } + [] tc_configureGuard.timeout { + log("**** TC_IMS_MESS_0001: StopTrafficCaptureReq not answered. ****"); + //setverdict (inconc); + } + } + f_cf_monitor_down(p_config.gmA); + f_cf_monitor_down(p_config.mw); + if(isvalue(p_config.gmB)) { + f_cf_monitor_down(p_config.gmB); + } + } + + /** + * @desc + * Roaming Call test configuration. Mapps/connects all related + * ports and initialize the test adapter. + * More information can be found in ETSI TS 186 011-2 V2.3.1 Cause + * 4.3.4. + * @param p_Gm Gm A Interface Monitor component + * @param p_ic Mw Interface Monitor component + */ + function f_cf_roam_call_up( + inout ImsInterfaceMonitor p_Gm, + inout ImsInterfaceMonitor p_ic + ) runs on ImsTestCoordinator { + // Initialize the Adapter (including the TrafficCapture process). + timer tc_configureGuard; + var StartTrafficCaptureRsp startResult; + activate(a_receiveIOTVerdict()); + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_generalConfigurationReq_offline); + alt { + [] acPort.receive (m_generalConfigurationRsp_success) { + log("General configuration succeed."); + tc_configureGuard.stop; + } + [] acPort.receive (m_generalConfigurationRsp_timeout) { + setverdict(fail); + tc_configureGuard.stop; + stop; + } + [] acPort.receive (m_generalConfigurationRsp_error) { + setverdict(fail); + tc_configureGuard.stop; + stop; + } + [] acPort.receive { + log("Unknown response."); + tc_configureGuard.stop; + setverdict (inconc); + stop; + } + [] tc_configureGuard.timeout { + log("Timeout."); + setverdict (inconc); + stop; + } + } + + f_cf_monitor_up(p_Gm); + f_cf_monitor_up(p_ic); + + // TODO UE IP address and port is missing + // TODO UE IP address and port is missing + p_Gm.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + f_getInterfaceInfoList("Gm", PX_EUT_A, PX_EUT_B) + ) + ))); + p_Gm.done; + + p_ic.start(f_cf_setFilter( + valueof(m_SetFilterReq( + e_sip, + f_getInterfaceInfoList("Ic", PX_EUT_A, PX_EUT_B) + ) + ))); + p_ic.done; + + // Start traffic capture processing. + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_startTrafficCaptureReq); + alt { + [] acPort.receive (m_startTrafficCaptureRsp_any) -> value startResult { + tc_configureGuard.stop; + if (startResult.status.code != e_success) + { + log("**** StartTrafficCaptureReq unsuccessfull! ****"); + setverdict(fail); + stop; + } + } + [] tc_configureGuard.timeout { + log("**** StartTrafficCaptureReq not answered. ****"); + setverdict (inconc); + stop; + } + } + } + + /** + * @desc + * Roaming Call test configuration. Ummaps/disconnect the + * related component ports. More information can be found in ETSI TS + * 186 011-2 V2.3.1 Cause 4.3.4. + * @param p_GmA Gm A Interface Monitor component + * @param p_ic Mw Interface Monitor component + */ + function f_cf_roam_call_down( + inout ImsInterfaceMonitor p_GmA, + inout ImsInterfaceMonitor p_ic + ) runs on ImsTestCoordinator { + // Stop traffic capture processing. + timer tc_configureGuard; + var StopTrafficCaptureRsp stopResult; + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_stopTrafficCaptureReq); + alt { + [] acPort.receive (m_stopTrafficCaptureRsp_any) -> value stopResult { + tc_configureGuard.stop; + if (stopResult.status.code != e_success) + { + log("**** TC_IMS_MESS_0001: StopTrafficCaptureReq unsuccessfull! ****"); + setverdict(fail); + } + } + [] tc_configureGuard.timeout { + log("**** TC_IMS_MESS_0001: StopTrafficCaptureReq not answered. ****"); + setverdict (inconc); + } + } + f_cf_monitor_down(p_GmA); + f_cf_monitor_down(p_ic); + } + + + /** + * @desc + * Roaming Call test configuration. Mapps/connects all related + * ports and initialize the test adapter. + * More information can be found in ETSI TS 186 011-2 V2.3.1 Cause + * 4.3.4. + * @param p_config.gmA Gm A Interface Monitor component + * @param p_config.mw Mw Interface Monitor component + * @param p_config.gmB Gm B Interface Monitor component + * @param p_config.iscA Isc A Interface Monitor component + * @param p_config.iscB Isc B Interface Monitor component + * IscA and IscB Interface Monitor component (optional, can be omitted) + */ + function f_cf_int_as_up( + inout CF_INT_AS p_config + ) runs on ImsTestCoordinator { + // Initialize the Adapter (including the TrafficCapture process). + timer tc_configureGuard; + var StartTrafficCaptureRsp startResult; + activate(a_receiveIOTVerdict()); + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_generalConfigurationReq_offline); + alt { + [] acPort.receive (m_generalConfigurationRsp_success) { + log("General configuration succeed."); + tc_configureGuard.stop; + } + [] acPort.receive (m_generalConfigurationRsp_timeout) { + setverdict(fail); + tc_configureGuard.stop; + stop; + } + [] acPort.receive (m_generalConfigurationRsp_error) { + setverdict(fail); + tc_configureGuard.stop; + stop; + } + [] acPort.receive { + log("Unknown response."); + tc_configureGuard.stop; + setverdict (inconc); + stop; + } + [] tc_configureGuard.timeout { + log("Timeout."); + setverdict (inconc); + stop; + } + } + + f_cf_monitor_up(p_config.gmA); + f_cf_monitor_up(p_config.mw); + f_cf_monitor_up(p_config.gmB); + if(isvalue(p_config.iscA)) { + f_cf_monitor_up(p_config.iscA); + } + if(isvalue(p_config.iscB)) { + f_cf_monitor_up(p_config.iscB); + } + + // TODO UE IP address and port is missing + p_config.gmA.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + {f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_A])} + ) + ))); + p_config.gmA.done; + + p_config.mw.start(f_cf_setFilter( + valueof(m_SetFilterReq( + e_sip, + f_getInterfaceInfoList("Ic", PX_EUT_A, PX_EUT_B) + ) + ))); + p_config.mw.done; + + p_config.gmB.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + {f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_B])} + ) + ))); + p_config.gmB.done; + + if(isvalue(p_config.iscA)) { + p_config.iscA.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + {f_getInterfaceInfo("Isc", PX_PRODUCTS[PX_EUT_A])} + ) + ))); + p_config.iscA.done; + } + + if(isvalue(p_config.iscB)) { + p_config.iscB.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + {f_getInterfaceInfo("Isc", PX_PRODUCTS[PX_EUT_B])} + ) + ))); + p_config.iscB.done; + } + + // Start traffic capture processing. + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_startTrafficCaptureReq); + alt { + [] acPort.receive (m_startTrafficCaptureRsp_any) -> value startResult { + tc_configureGuard.stop; + if (startResult.status.code != e_success) + { + log("**** StartTrafficCaptureReq unsuccessfull! ****"); + setverdict(fail); + stop; + } + } + [] tc_configureGuard.timeout { + log("**** StartTrafficCaptureReq not answered. ****"); + setverdict (inconc); + stop; + } + } + } + + /** + * @desc + * Interworking Application Server test configuration. + * Ummaps/disconnect the related component ports. More information + * can be found in ETSI TS 186 011-2 V2.3.1 Cause 4.3.4. + * @param p_config.gmA Gm A Interface Monitor component + * @param p_config.mw Mw Interface Monitor component + * @param p_config.gmB Gm B Interface Monitor component + * @param p_config.iscA Isc A Interface Monitor component + * @param p_config.iscB Isc B Interface Monitor component + * IscA and IscB Interface Monitor component (optional, can be omitted) + */ + function f_cf_int_as_down( + inout CF_INT_AS p_config + ) runs on ImsTestCoordinator { + // Stop traffic capture processing. + timer tc_configureGuard; + var StopTrafficCaptureRsp stopResult; + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_stopTrafficCaptureReq); + alt { + [] acPort.receive (m_stopTrafficCaptureRsp_any) -> value stopResult { + tc_configureGuard.stop; + if (stopResult.status.code != e_success) + { + log("**** TC_IMS_MESS_0001: StopTrafficCaptureReq unsuccessfull! ****"); + setverdict(fail); + } + } + [] tc_configureGuard.timeout { + log("**** TC_IMS_MESS_0001: StopTrafficCaptureReq not answered. ****"); + //setverdict (inconc); + } + } + f_cf_monitor_down(p_config.gmA); + f_cf_monitor_down(p_config.mw); + f_cf_monitor_down(p_config.gmB); + if(isvalue(p_config.iscA)) { + f_cf_monitor_down(p_config.iscA); + } + if(isvalue(p_config.iscB)) { + f_cf_monitor_down(p_config.iscB); + } + } + + + /** + * @desc + * Roaming Call test configuration. Mapps/connects all related + * ports and initialize the test adapter. + * More information can be found in ETSI TS 186 011-2 V2.3.1 Cause + * 4.3.4. + * @param p_config.gmA Gm A Interface Monitor component + * @param p_config.mw Mw Interface Monitor component + * @param p_config.gmB Gm B Interface Monitor component + * @param p_config.iscA Isc A Interface Monitor component + * @param p_config.iscB Isc B Interface Monitor component + * IscA and IscB Interface Monitor component (optional, can be omitted) + */ + function f_cf_roam_as_up( + inout CF_ROAM_AS p_config + ) runs on ImsTestCoordinator { + // Initialize the Adapter (including the TrafficCapture process). + timer tc_configureGuard; + var StartTrafficCaptureRsp startResult; + activate(a_receiveIOTVerdict()); + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_generalConfigurationReq_offline); + alt { + [] acPort.receive (m_generalConfigurationRsp_success) { + log("General configuration succeed."); + tc_configureGuard.stop; + } + [] acPort.receive (m_generalConfigurationRsp_timeout) { + setverdict(fail); + tc_configureGuard.stop; + stop; + } + [] acPort.receive (m_generalConfigurationRsp_error) { + setverdict(fail); + tc_configureGuard.stop; + stop; + } + [] acPort.receive { + log("Unknown response."); + tc_configureGuard.stop; + setverdict (inconc); + stop; + } + [] tc_configureGuard.timeout { + log("Timeout."); + setverdict (inconc); + stop; + } + } + + f_cf_monitor_up(p_config.gmA); + f_cf_monitor_up(p_config.mw); + f_cf_monitor_up(p_config.gmB); + if(isvalue(p_config.iscA)) { + f_cf_monitor_up(p_config.iscA); + } + if(isvalue(p_config.iscB)) { + f_cf_monitor_up(p_config.iscB); + } + + // TODO UE IP address and port is missing + p_config.gmA.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + {f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_A])} + ) + ))); + p_config.gmA.done; + + p_config.mw.start(f_cf_setFilter( + valueof(m_SetFilterReq( + e_sip, + f_getInterfaceInfoList("Ic", PX_EUT_A, PX_EUT_B) + ) + ))); + p_config.mw.done; + + p_config.gmB.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + {f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_B])} + ) + ))); + p_config.gmB.done; + + if(isvalue(p_config.iscA)) { + p_config.iscA.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + {f_getInterfaceInfo("Isc", PX_PRODUCTS[PX_EUT_A])} + ) + ))); + p_config.iscA.done; + } + + if(isvalue(p_config.iscB)) { + p_config.iscB.start(f_cf_setFilter( + valueof (m_SetFilterReq( + e_sip, + {f_getInterfaceInfo("Isc", PX_PRODUCTS[PX_EUT_B])} + ) + ))); + p_config.iscB.done; + } + + // Start traffic capture processing. + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_startTrafficCaptureReq); + alt { + [] acPort.receive (m_startTrafficCaptureRsp_any) -> value startResult { + tc_configureGuard.stop; + if (startResult.status.code != e_success) + { + log("**** StartTrafficCaptureReq unsuccessfull! ****"); + setverdict(fail); + stop; + } + } + [] tc_configureGuard.timeout { + log("**** StartTrafficCaptureReq not answered. ****"); + setverdict (inconc); + stop; + } + } + } + + /** + * @desc + * Interworking Application Server test configuration. + * Ummaps/disconnect the related component ports. More information + * can be found in ETSI TS 186 011-2 V2.3.1 Cause 4.3.4. + * @param p_config.gmA Gm A Interface Monitor component + * @param p_config.mw Mw Interface Monitor component + * @param p_config.gmB Gm B Interface Monitor component + * @param p_config.iscA Isc A Interface Monitor component + * @param p_config.iscB Isc B Interface Monitor component + * IscA and IscB Interface Monitor component (optional, can be omitted) + */ + function f_cf_roam_as_down( + inout CF_ROAM_AS p_config + ) runs on ImsTestCoordinator { + // Stop traffic capture processing. + timer tc_configureGuard; + var StopTrafficCaptureRsp stopResult; + tc_configureGuard.start(PX_MAX_MSG_WAIT); + acPort.send(m_stopTrafficCaptureReq); + alt { + [] acPort.receive (m_stopTrafficCaptureRsp_any) -> value stopResult { + tc_configureGuard.stop; + if (stopResult.status.code != e_success) + { + log("**** TC_IMS_MESS_0001: StopTrafficCaptureReq unsuccessfull! ****"); + setverdict(fail); + } + } + [] tc_configureGuard.timeout { + log("**** TC_IMS_MESS_0001: StopTrafficCaptureReq not answered. ****"); + setverdict (inconc); + } + } + f_cf_monitor_down(p_config.gmA); + f_cf_monitor_down(p_config.mw); + f_cf_monitor_down(p_config.gmB); + if(isvalue(p_config.iscA)) { + f_cf_monitor_down(p_config.iscA); + } + if(isvalue(p_config.iscB)) { + f_cf_monitor_down(p_config.iscB); + } + } + } + + function f_getInterfaceInfoList( + in charstring p_interfaceName, + in integer p_product1, + in integer p_product2 + ) return InterfaceInfoList { + var InterfaceInfoList v_list := { + f_getInterfaceInfo(p_interfaceName, PX_PRODUCTS[p_product1]), + f_getInterfaceInfo(p_interfaceName, PX_PRODUCTS[p_product2]) + }; + + return v_list; + } + + function f_getInterfaceInfo(in charstring p_interfaceName, Product p_product) return InterfaceInfo { + var InterfaceInfo v_info := { + IpInterfaceInfo := { + { + domainName := "invalid", + IpAddress := "0.0.0.0", + portNumbers := {0} + } + } + }; + + for(var integer i := 0; i < lengthof(p_product.monitorInterfaces); i := i + 1) { // YANN: <= instead of < + if(p_product.monitorInterfaces[i].interfaceName == p_interfaceName) { + return p_product.monitorInterfaces[i].interfaceInfo; + } + } + + return v_info; + } + + + + +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestControl.ttcn3 =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestControl.ttcn3 (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestControl.ttcn3 (revision 18) @@ -0,0 +1,29 @@ +/** + * @author STF 370 + * @version $Id: $ + * @desc This module provides ATS specific test control declarations. + */ +module AtsImsIot_TestControl { + import from AtsImsIot_TestCases_CALL all; + import from AtsImsIot_TestCases_MESS all; + import from AtsImsIot_TestCases_REG all; + import from AtsImsIot_TestCases_SS all; + + control { + // MESS TCs + //execute(TC_IMS_MESS_0001()); + + // CALL TCs + //execute(TC_IMS_CALL_0001()); + //execute(TC_IMS_CALL_0003()); // OK + //execute(TC_IMS_CALL_0007()); + //execute(TC_IMS_CALL_0017()); + + // REG TCs + execute(TC_IMS_REG_0002()); + //execute(TC_IMS_REG_0003()); + + // SS TCs + //execute(TC_IMS_SS_0006()); + } +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestSystem.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestSystem.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TestSystem.ttcn (revision 18) @@ -0,0 +1,74 @@ +module AtsImsIot_TestSystem { + + import from LibSip_SIPTypesAndValues {type Request, Response;} + + import from AtsImsIot_TypesAndValues {type SipMessage;} + + import from LibIot_TestInterface {type EquipmentAccessPort;} + + import from LibIot_TestInterface all; + + /** + * @desc interfaces to the SUT + */ + type component IotSystemInterface { + port DataPort dPort; + port EquipmentAccessPort eaPort; + port AdapterConfigPort acPort; + } + + /** + * @desc + * providing monitoring functionality of involved interfaces. Used as + * PTC. + */ + type component ImsInterfaceMonitor extends InterfaceMonitor { + port DataPort dPort; + port ImsCoordinationPort icpPort; + } + + /** + * @desc + * used to coordinate the behavior of other components. It is in charge + * of controlling the overall execution, manangement of testing phases, + * test verdicts collection and synchronization. Used as MTC. + */ + type component ImsTestCoordinator extends TestCoordinator { + port ImsCoordinationPort icpPort; + } + + group portDefinitions { + + type port ImsCoordinationPort message { + inout SipMessage; + } + + type port DataPort message { + in Request, Response; // SIP + // TODO DNS .. or union + } + + } + + type record CF_INT_CALL { + ImsInterfaceMonitor gmA, + ImsInterfaceMonitor mw, + ImsInterfaceMonitor gmB optional + } + + type record CF_INT_AS { + ImsInterfaceMonitor gmA, + ImsInterfaceMonitor mw, + ImsInterfaceMonitor gmB, + ImsInterfaceMonitor iscA optional, + ImsInterfaceMonitor iscB optional + } + + type record CF_ROAM_AS { + ImsInterfaceMonitor gmA, + ImsInterfaceMonitor mw, + ImsInterfaceMonitor gmB, + ImsInterfaceMonitor iscA optional, + ImsInterfaceMonitor iscB optional + } +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TypesAndValues.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TypesAndValues.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/AtsImsIot/AtsImsIot_TypesAndValues.ttcn (revision 18) @@ -0,0 +1,33 @@ +/* + * @author STF 370 + * @version $Id: $ + * @desc This module provides the templates for Interoperability tests. + */ + +module AtsImsIot_TypesAndValues { + + import from LibSip_SIPTypesAndValues {type Request, Response;} + + group SIPmessageTypes { + /** + * @desc SIP Message Type + * @member request SIP request + * @member response SIP response + */ + type union SipMessage { + Request request, + Response response + } + + /** + * @desc SIP Message List Type + */ + type record of SipMessage SipMessageList; + + type record SkipType { + integer skipCount, + SipMessage skipMessage optional + } + } + +}//end module Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIms_ConfigAndTrigger/LibIms_UpperTester.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIms_ConfigAndTrigger/LibIms_UpperTester.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIms_ConfigAndTrigger/LibIms_UpperTester.ttcn (revision 18) @@ -0,0 +1,516 @@ +/** + * @author STF 370 + * @version $Id:$ + * @desc This module provides trigger and configuration functions for IMS. + */ +module LibIms_UpperTester { + + + import from LibIot_Functions {function f_sendEquipmentCmd;} + + import from LibUpperTester { + template m_EQ_Request; + type EquipmentCommand; + } + + import from LibIot_TestInterface {type TestCoordinator, EquipmentUser;} + + group ue { + group ueTypes { + group ueCommands { + + /** + * @desc Command to trigger registration of the UE + * @remark + * Note that the registration trigger command needs has + * additional parameter for the public, private user id and + * password. + * @remark + * Note that the user friendly application and the upper test + * adapter may need to be uparaded if new messages are added. + */ + const EquipmentCommand c_UE_REGISTRATION := "UE_REGISTRATION"; + const EquipmentCommand c_UE_CHECKisREGISTERED := "UE_CHECK_IS_REGISTER"; + const EquipmentCommand c_UE_CHECKisnotREGISTERED := "UE_CHECK_IS_NOT_REGISTERED"; + const EquipmentCommand c_UE_CHECK_CALLisINITIALIZED := "UE_CHECK_CALL_IS_INITIALIZED"; + const EquipmentCommand c_UE_CHECK_CALLisANSWERED := "UE_CHECK_CALL_IS_ANSWERED"; + const EquipmentCommand c_UE_CHECK_CALLisENDED := "UE_CHECK_CALL_IS_ENDED"; + const EquipmentCommand c_UE_CHECK_NEWMEDIASTREAMisADDED := "UE_CHECK_NEW_MEDIA_STREAM_IS_ADDED"; + const EquipmentCommand c_UE_CHECK_REMOVEMEDIASTREAMisADDED := "UE_CHECK_NEW_MEDIA_STREAM_IS_REMOVED"; + + + /** + * + * @desc Command to trigger de-registration of the UE + */ + const EquipmentCommand c_UE_DEREGISTRATION := "UE_DEREGISTRATION"; + + /** + * @desc Command to trigger UE to send a message + */ + const EquipmentCommand c_UE_SEND_MESSAGE := "UE_SEND_MESSAGE"; + + /** + * @desc Command to check if UE has receipt of a message + */ + const EquipmentCommand c_UE_CHECK_MESSAGE_RECEIPT := "UE_CHECK_MESSAGE_RECEIPT"; + + + /** + * @desc Command to check if UE is informed about that the message request could not be delivered. + */ + const EquipmentCommand c_UE_CHECK_MESSAGE_NOT_DELIVERED := "UE_CHECK_MESSAGE_NOT_DELIVERED"; + } + } + + group ueFunctions { + + + /** + * + * @desc Triggers registration of a given user via UE + * @param p_publicId The public user identity + * @param p_privateId The private user identity + * @param p_pw The users password + * @verdict e2e verdict will be set depending on the result of trigger action + */ + function f_userRegistration(in charstring p_publicId, in charstring p_privateId, in charstring p_pw) + runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_REGISTRATION, {p_publicId, p_privateId, p_pw}))); + } + + function f_checkUserIsRegistered() + runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_CHECKisREGISTERED, {}))); + } + function f_checkUserIsNotRegistered() + runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_CHECKisnotREGISTERED, {}))); + } + function f_checkUserCallIsInitiated() + runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_CHECK_CALLisINITIALIZED, {}))); + } + function f_checkUserCallIsAnswered() + runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_CHECK_CALLisANSWERED, {}))); + } + function f_checkUserCallIsEnded() + runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_CHECK_CALLisENDED, {}))); + } + function f_checkUserAddNewMediaStream() + runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_CHECK_NEWMEDIASTREAMisADDED, {}))); + } + function f_checkUserRemoveNewMediaStream() + runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_CHECK_REMOVEMEDIASTREAMisADDED, {}))); + } + /** + * + * @desc Triggers de-registration of a given user via UE + * @param p_publicId The public user name + * @verdict e2e verdict will be set depending on the result of trigger action + */ + function f_userDeregistration(in charstring p_publicId) + runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_DEREGISTRATION, {p_publicId}))); + } + + /** + * + * @desc Trigger sending an instant message via UE + */ + function f_userSendMessage(in charstring p_body) + runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_SEND_MESSAGE, {p_body}))); + } + + /** + * + * @desc Trigger checking the receipt of instant message at UE + */ + function f_userCheckMessageReceipt() runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_CHECK_MESSAGE_RECEIPT, {}))); + } + + /** + * + * @desc Trigger checking the receipt of instant message at UE + */ + function f_userCheckMessageNotDelivered() runs on EquipmentUser { + f_sendEquipmentCmd(valueof(m_EQ_Request(c_UE_CHECK_MESSAGE_NOT_DELIVERED, {}))); + } + } + } + + group LibUEModuleParameters { + + /** + * + * @desc Required information for user components + * @member publicId public user identity + * @member privateId private user identity + * @member password user password + * @member domain Home domain of user + * @member domainProxy Entry point to either home or roaming IMS network + */ + type record ImsUserInfo { + charstring publicId, // (default) id to be used by UE + charstring privateId, + charstring password, + charstring domain, + charstring domainProxy + } + + type union ImsUserIdentity { + ImsUserInfo genUserId, + ImsUserInfo sipUserId, + ImsUserInfo telUserId, + ImsUserInfo noasUserId, + ImsUserInfo holdUserId, + ImsUserInfo oipUserId, + ImsUserInfo oirUserId, + ImsUserInfo acrUserId, + ImsUserInfo cfuUserId, + ImsUserInfo presUserId, + ImsUserInfo iptvUserId + } + + /** + * + * @desc List of IMS user information + */ + type record of ImsUserIdentity ImsUserIdentityList ; + + /** + * + * @desc The record collects IMS user information configured in one specific core IMS + * @member productIndex index pointing to the entry of the core IMS product in PX_PRODUCTS + * @member userInfos Lists information about all users configured in the HSS of this core IMS + */ + type record CoreImsUserInfo { + integer productIndex, + ImsUserIdentityList userIds + } + + /** + * + * @desc Collects IMS user information configured in all core IMS participating in the interoperability event + */ + type record of CoreImsUserInfo CoreImsUserInfoList; + + + /** + * + * @desc Example of module parameter based entry of EUT interface information for all products particpating in an interoperability event + */ + modulepar CoreImsUserInfoList PX_IMS_USER_DATA := { + { + productIndex := 0, // Ericsson + userIds := { + { + genUserId := { + publicId := "userGEN", + privateId := "userGEN_priv", + password := "123456", + domain := "ericsson.etsi", + domainProxy := "pcscf.ericsson.etsi" //pcscf domain or IPaddress + + }}, + { + sipUserId := { + publicId := "userSIP", + privateId := "userSIP_priv", + password := "123456", + domain := "ericsson.etsi", + domainProxy := "pcscf.ericsson.etsi" //pcscf domain or IPaddress + + }}, + { + telUserId := { + publicId := "tel: 3344123432", + privateId := "userTEL_priv", + password := "123456", + domain := "ericsson.etsi", + domainProxy := "pcscf.ericsson.etsi" //pcscf domain or IPaddress + }} + } + }, + { + productIndex := 1, // Thomson + userIds := { + { + genUserId := { + publicId := "userSIP", + privateId := "userSIP_priv", + password := "123456", + domain := "thomson.etsi", + domainProxy := "pcscf.thomson.etsi" //pcscf domain or IPaddress + + }}, + { + sipUserId := { + publicId := "userSIP", + privateId := "userSIP_priv", + password := "123456", + domain := "thomson.etsi", + domainProxy := "pcscf.thomson.etsi" //pcscf domain or IPaddress + }}, + { + telUserId := { + publicId := "tel: 3344123443", + privateId := "userTEL_priv", + password := "123456", + domain := "thomson.etsi", + domainProxy := "pcscf.thomson.etsi" //pcscf domain or IPaddress + }} + } + }, + { + productIndex := 2, // NSN + userIds := { + { + genUserId := { + publicId := "userGEN", + privateId := "userGEN_priv", + password := "123456", + domain := "nsn.etsi", + domainProxy := "pcscf.nsn.etsi" //pcscf domain or IPaddress + + }}, + { + sipUserId := { + publicId := "userSIP", + privateId := "userSIP_priv", + password := "123456", + domain := "nsn.etsi", + domainProxy := "pcscf.nsn.etsi" //pcscf domain or IPaddress + }}, + { + telUserId := { + publicId := "tel: 3344123443", + privateId := "userTEL_priv", + password := "123456", + domain := "nsn.etsi", + domainProxy := "pcscf.nsn.etsi" //pcscf domain or IPaddress + }} + } + }, + { + productIndex := 3, // Italtel + userIds := { + { + genUserId := { + publicId := "userGEN", + privateId := "userGEN_priv", + password := "123456", + domain := "italtel.etsi", + domainProxy := "pcscf.italtel.etsi" //pcscf domain or IPaddress + + }}, + { + sipUserId := { + publicId := "userSIP", + privateId := "userSIP_priv", + password := "123456", + domain := "italtel.etsi", + domainProxy := "pcscf.italtel.etsi" //pcscf domain or IPaddress + }}, + { + telUserId := { + publicId := "tel: 3344123443", + privateId := "userTEL_priv", + password := "123456", + domain := "italtel.etsi", + domainProxy := "pcscf.italtel.etsi" //pcscf domain or IPaddress + }} + } + }, + { + productIndex := 4, // EXFO + userIds := { + { + genUserId := { + publicId := "userGEN", + privateId := "userGEN_priv", + password := "123456", + domain := "exfo.etsi", + domainProxy := "pcscf.exfo.etsi" //pcscf domain or IPaddress + + }}, + { + sipUserId := { + publicId := "userSIP", + privateId := "userSIP_priv", + password := "123456", + domain := "exfo.etsi", + domainProxy := "pcscf.exfo.etsi" //pcscf domain or IPaddress + }}, + { + telUserId := { + publicId := "tel: 3344123443", + privateId := "userTEL_priv", + password := "123456", + domain := "exfo.etsi", + domainProxy := "pcscf.exfo.etsi" //pcscf domain or IPaddress + }} + } + }, + { + productIndex := 5, // Iskratel + userIds := { + { + genUserId := { + publicId := "userGEN", + privateId := "userGEN_priv", + password := "123456", + domain := "iskratel.etsi", + domainProxy := "pcscf.iskratel.etsi" //pcscf domain or IPaddress + + }}, + { + sipUserId := { + publicId := "userSIP", + privateId := "userSIP_priv", + password := "123456", + domain := "iskratel.etsi", + domainProxy := "pcscf.iskratel.etsi" //pcscf domain or IPaddress + }}, + { + telUserId := { + publicId := "tel: 3344123443", + privateId := "userTEL_priv", + password := "123456", + domain := "iskratel.etsi", + domainProxy := "pcscf.iskratel.etsi" //pcscf domain or IPaddress + }} + } + }, + { + productIndex := 6, // Testing Tech IMS Core + userIds := { + { + genUserId := { + publicId := "userGEN", + privateId := "userGEN_priv", + password := "123456", + domain := "testingtech.com", + domainProxy := "pcscf.testingtech.com" //pcscf domain or IPaddress + + }}, + { + sipUserId := { + publicId := "userSIP", + privateId := "userSIP_priv", + password := "123456", + domain := "testingtech.com", + domainProxy := "pcscf.testingtech.com" //pcscf domain or IPaddress + }}, + { + telUserId := { + publicId := "tel: 3344123443", + privateId := "userTEL_priv", + password := "123456", + domain := "testingtech.com", + domainProxy := "pcscf.testingtech.com" //pcscf domain or IPaddress + }} + } + }, + { + productIndex := 7, // Acme + userIds := { + { + genUserId := { + publicId := "userGEN", + privateId := "userGEN_priv", + password := "123456", + domain := "acme.etsi", + domainProxy := "pcscf.acme.etsi" //pcscf domain or IPaddress + + }}, + { + sipUserId := { + publicId := "userSIP", + privateId := "userSIP_priv", + password := "123456", + domain := "acme.etsi", + domainProxy := "acme" //pcscf domain or IPaddress + }}, + { + telUserId := { + publicId := "tel: 3344123443", + privateId := "userTEL_priv", + password := "123456", + domain := "acme.etsi", + domainProxy := "pcscf.acme.etsi" //pcscf domain or IPaddress + }} + } + }, + { + productIndex := 8, // Nexcom + userIds := { + { + genUserId := { + publicId := "userGEN", + privateId := "userSIP_priv", + password := "123456", + domain := "nexcom.etsi", + domainProxy := "pcscf.nexcom.etsi" //pcscf domain or IPaddress + + }}, + { + sipUserId := { + publicId := "userGEN", + privateId := "userSIP_priv", + password := "123456", + domain := "nexcom.etsi", + domainProxy := "pcscf.nexcom.etsi" //pcscf domain or IPaddress + }}, + { + telUserId := { + publicId := "tel: 3344123443", + privateId := "userTEL_priv", + password := "123456", + domain := "nexcom.etsi", + domainProxy := "pcscf.nexcom.etsi" //pcscf domain or IPaddress + }} + } + }, + { + productIndex := 9, // Hotaro + userIds := { + { + genUserId := { + publicId := "userGEN", + privateId := "userGEN_priv", + password := "123456", + domain := "hotaro.etsi", + domainProxy := "pcscf.hotaro.etsi" //pcscf domain or IPaddress + + }}, + { + sipUserId := { + publicId := "userSIP", + privateId := "userSIP_priv", + password := "123456", + domain := "hotaro.etsi", + domainProxy := "pcscf.hotaro.etsi" //pcscf domain or IPaddress + }}, + { + telUserId := { + publicId := "tel: 3344123443", + privateId := "userTEL_priv", + password := "123456", + domain := "hotaro.etsi", + domainProxy := "pcscf.hotaro.etsi" //pcscf domain or IPaddress + }} + } + } + }// end modulepar + } // end group + + group eut { + } +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_Functions.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_Functions.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_Functions.ttcn (revision 18) @@ -0,0 +1,231 @@ +/* + * @author STF 370 + * @version $Id: LibIot_Functions.ttcn 16 2009-06-16 15:06:42Z pintar $ + * @desc This module provides the functions used by the test component + */ + +module LibIot_Functions { + import from LibCommon_VerdictControl {type FncRetCode;} + + import from LibUpperTester { + template mw_EO_Response; + type EquipmentOperationReq, EquipmentOperationRsp; + } + + import from LibIot_TypesAndValues { + type IotVerdict, IotVerdictType, Status, VerdictType; + } + + import from LibIot_PIXITS { + modulepar PX_EUT_TRIGGER_RESPONSE, PX_TTCN3_VERDICT; + } + + import from LibIot_TestInterface { + type IotEquipmentUser, OracleClient, OracleServer, TestCoordinator, EquipmentUser; + } + + + group oracleFunctions { + + /** + * @desc Sets the conformance verdict on the oracle client and sends it to the oracle server + * @param p_verdict conformance verdict set by the monitor + * @param p_reason reason why the verdict has been set + */ + function f_setConformanceVerdict(in verdicttype p_verdict, + in charstring p_reason) + runs on OracleClient { + var IotVerdict v_verdict := {conformance := {p_verdict, p_reason}}; + log("Conformance verdict set to: ", p_verdict, p_reason); + vPort.send(v_verdict); + } + + /** + * @desc Sets the end-to-end verdict on the oracle client and sends it to the oracle server + * @param p_verdict e2e verdict set by the monitor + * @param p_reason reason why the verdict has been set + */ + function f_setE2EVerdict(in verdicttype p_verdict, in charstring p_reason) + runs on OracleClient { + var IotVerdict v_verdict := {e2e := {p_verdict, p_reason}}; + log("E2E verdict set to: ", p_verdict, p_reason); + vPort.send(v_verdict); + } + + /** + * @desc Gets the conformance verdict on the oracle client + * @return conformance verdict of oracle server + */ + function f_getConformanceVerdict() + runs on OracleServer + return verdicttype { + return vc_conf_verdict.verdict; + } + + /** + * @desc Gets the end-to-end verdict on the oracle client + * @return end-to-end verdict of oracle server + */ + function f_getE2EVerdict() + runs on OracleServer + return verdicttype { + return vc_e3e_verdict.verdict; + } + + /** + * @desc Computes and logs overall verdict for end-to-end and conformance separately on oracle server + * @param p_verdict the verdict received + */ + function f_setIotVerdict(in IotVerdict p_verdict) runs on OracleServer { + f_logIotVerdict(p_verdict); + if (ischosen(p_verdict.e2e) and PX_TTCN3_VERDICT == e_e2e) { + setverdict(p_verdict.e2e.verdict, p_verdict.e2e.reason); + } else if (ischosen(p_verdict.conformance) and PX_TTCN3_VERDICT == e_conformance) { + setverdict(p_verdict.conformance.verdict, p_verdict.conformance.reason); + } + } + + /** + * @desc Set verdict PASS on main component (to be used, e.g on TestCoordinator) + */ + function f_setIotVerdictPASS(in charstring p_reason) runs on OracleServer { + var IotVerdict p_verdict := { + conformance := {verdict := pass, reason := p_reason} + }; + f_setIotVerdict(p_verdict); + } + /** + * @desc Set verdict PASS on main component (to be used, e.g on TestCoordinator) + */ + function f_setIotVerdictFAIL(in charstring p_reason) runs on OracleServer { + var IotVerdict p_verdict := { + conformance := {verdict := fail, reason := p_reason} + }; + f_setIotVerdict(p_verdict); + } + + + /** + * + * @desc logs the received IOT verdict + * @param p_verdict The verdict to set + */ + function f_logIotVerdict(in IotVerdict p_verdict) runs on OracleServer { + if (ischosen(p_verdict.e2e)) { + vc_e3e_verdict := f_getWorseVerdict(vc_e3e_verdict, p_verdict.e2e); + log("E2E verdict set to: ", p_verdict.e2e.verdict, "Reason: " & p_verdict.e2e.reason); + } else { + vc_conf_verdict := f_getWorseVerdict(vc_conf_verdict, p_verdict.conformance); + log("Conformance verdict set to: ", p_verdict.conformance.verdict, "Reason: " & p_verdict.conformance.reason); + } + } + + /** + * + * @desc returns the worse verdict + * @param p_org the original verdict + * @param p_new the new verdict + * @return the worse verdict + */ + function f_getWorseVerdict(in VerdictType p_org, in VerdictType p_new) return VerdictType { + if(p_org.verdict == pass) { + + if(p_new.verdict != pass) { + return p_new; + } + else { + return p_org; + } + } + else if (p_org.verdict == inconc) { + + if(p_new.verdict != pass) { + return p_new; + } + else { + return p_org; + } + } + else if (p_org.verdict == fail) { + if(p_new.verdict == pass) { + return p_org; + } + else if(p_new.verdict == inconc) { + return p_org; + } + else { + return p_new; + } + } + else if (p_org.verdict == error) { + return p_org; + } + + return p_org; + } + + /** + * @desc Altstep to be used for listening continously on the verdict port of the oracle server for receiving verdicts from oracle clients + */ + altstep a_receiveIOTVerdict() runs on OracleServer { + var IotVerdict v_verdict; + [] vPort.receive(IotVerdict:?) -> value v_verdict { + f_setIotVerdict(v_verdict); + repeat; + } + } + } + + group equipmentOperationFunctions { // TODO Update! + function f_sendEquipmentCmd(in EquipmentOperationReq p_req) runs on EquipmentUser { + var EquipmentOperationRsp v_response; + var charstring v_reason := ""; + + T_Equipment.start(PX_EUT_TRIGGER_RESPONSE); + eaPort.send(p_req); + + alt{ + [] eaPort.receive(mw_EO_Response(e_success)) -> value v_response { + T_Equipment.stop; + if(ispresent(v_response.status.reason)) { + v_reason := v_response.status.reason; + f_setE2EVerdict(pass, "Equipment command """ & p_req.cmd & """successful: " & v_reason); + }else { + f_setE2EVerdict(pass, "Equipment command successful"); + } + } + [] eaPort.receive(mw_EO_Response(?)) -> value v_response { + T_Equipment.stop; + if(ispresent(v_response.status.reason)) { + v_reason := v_response.status.reason; + f_setE2EVerdict(fail, "Equipment command """ & p_req.cmd & """unsuccessful: " & v_reason); + }else { + f_setE2EVerdict(fail, "Equipment command unsuccessful: no reason given"); + } + } + [] T_Equipment.timeout { + f_setE2EVerdict(inconc, "Timer expired while waiting for reponse of Trigger command """ & p_req.cmd & """"); + } + } + } + } + + group miscFunctions { + /** + * @desc searches the array for a given name and returns + * the corresponding index + * @param p_idx index of the port + * @return the index + */ + function f_getMonitorIdx(in charstring p_name) + runs on TestCoordinator return integer { + var integer v_size := sizeof(vc_compIds); + for (var integer i := 0; i < v_size; i := i + 1) { + if (vc_compIds[i].name == p_name) { + return vc_compIds[i].index; + } + } + return - 1; + } + } +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_PIXITS.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_PIXITS.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_PIXITS.ttcn (revision 18) @@ -0,0 +1,1040 @@ +/* + * @author STF 370 + * @version $Id: LibIot_PIXITS.ttcn 277 2009-06-16 15:06:42Z pintar $ + * @desc This module provides PIXIT parameters which need to be + * changeable within validation + */ + +module LibIot_PIXITS { + + import from LibIot_TypesAndValues + { + type IOTExecMode, IotVerdictType, CaptureMode, RecordMode, FileList, TimeOffset, EutInterfaceInfoList, + ProtocolFilter, IpAddress, PortNumber, ProductList, InterfaceAvailableList; + } + + /** + * @desc PIXIT defines which verdict (E2E or conformance)is to be kept track of with the TTCN-3 verdict. + * Note that the verdict not chosen will be only available in log statements. + */ + modulepar IotVerdictType PX_TTCN3_VERDICT := e_conformance; + + /** + * + * @desc Maximum time limit used by monitor component for waiting for expected incoming messages + */ + modulepar float PX_MAX_MSG_WAIT := 10.0; + + /** + * + * @desc Example of module parameter based entry of EUT interface information for all products particpating in an interoperability event + */ + modulepar ProductList PX_PRODUCTS := { + { + // productIndex = 0 + productName := "Ericsson", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.ericsson.etsi", + IpAddress := "192.86.1.97", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.2", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.3", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.37", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.38", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.66", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.67", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.98", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.99", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.ericsson.etsi", + IpAddress := "192.86.1.97", + portNumbers := {5060} + }, + { + domainName := "icscf.ericsson.etsi", + IpAddress := "192.86.1.98", + portNumbers := {5060} + }, + { + domainName := "scscf.ericsson.etsi", + IpAddress := "192.86.1.99", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "telephonyas.ericsson.etsi", + IpAddress := "192.86.1.109", + portNumbers := {} + }, + { + domainName := "presenceas.ericsson.etsi", + IpAddress := "192.86.1.106", + portNumbers := {} + }, + { + domainName := "mtasout.ericsson.etsi", + IpAddress := "0.0.0.0", + portNumbers := {} + }, + { + domainName := "scscf.ericsson.etsi", + IpAddress := "192.86.1.99", + portNumbers := {5060} + } + + } + } + } + } + }, + { + // productIndex = 1 + productName := "Thomson", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.thomson.etsi", + IpAddress := "10.10.2.10", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.8", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.9", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.41", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.42", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.70", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.71", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.106", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.107", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.thomson.etsi", + IpAddress := "10.10.2.10", + portNumbers := {5060} + }, + { + domainName := "icscf.thomson.etsi", + IpAddress := "10.10.2.10", + portNumbers := {5180,5185} + }, + { + domainName := "scscf.thomson.etsi", + IpAddress := "10.10.2.10", + portNumbers := {5185,5187,5188,5189} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.thomson.etsi", + IpAddress := "10.10.2.10", + portNumbers := {5060} + }, + { + domainName := "telephonyas.thomson.net", + IpAddress := "10.10.2.20", + portNumbers := {5076} + } + } + } + } + } + }, + { + // productIndex = 2 + productName := "NSN", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf-gm.nsn.etsi", + IpAddress := "10.10.1.99", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.16", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.17", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.39", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.40", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.68", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.69", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.100", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.101", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf-mw.nsn.etsi", + IpAddress := "10.10.1.67", + portNumbers := {5070} + }, + { + domainName := "icscf.nsn.etsi", + IpAddress := "10.10.1.67", + portNumbers := {5080} + }, + { + domainName := "scscf.nsn.etsi", + IpAddress := "10.10.1.67", + portNumbers := {5090} + }, + { + domainName := "pcscf-mw.nsn.etsi", + IpAddress := "10.10.1.67", + portNumbers := {5070} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "as.nsn.etsi", + IpAddress := "0.0.0.0", + portNumbers := {5060} + } + } + } + } + } + }, + { + // productIndex = 3 + productName := "Italtel", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.italtel.net", + IpAddress := "172.31.14.6", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "icscf.italtel.net", + IpAddress := "172.31.14.2", + portNumbers := {5160} + }, + { + domainName := "scscf.italtel.net", + IpAddress := "172.31.14.10", + portNumbers := {5160} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "as.italtel.net", + IpAddress := "172.31.14.6", + portNumbers := {5060} + } + } + } + } + } + }, + { + // productIndex = 4 + productName := "EXFO", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.exfo.net", + IpAddress := "172.31.15.3", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "icscf.exfo.net", + IpAddress := "172.31.15.2", + portNumbers := {5160} + }, + { + domainName := "scscf.exfo", + IpAddress := "172.31.15.4", + portNumbers := {5160} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "as.exfo.net", + IpAddress := "172.31.15.6", + portNumbers := {5060} + } + } + } + } + } + }, + { + // productIndex = 5 + productName := "Iskratel", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "ptech.iskratel.etsi", + IpAddress := "10.10.14.14", + portNumbers := {5070} + }, + { + domainName := omit, + IpAddress := "10.10.20.6", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.7", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.35", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.36", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.74", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.75", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.104", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.105", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "ptech.iskratel.etsi", + IpAddress := "10.10.14.14", + portNumbers := {5070} + }, + { + domainName := "itech.iskratel.etsi", + IpAddress := "10.10.14.10", + portNumbers := {5080} + }, + { + domainName := "stech.iskratel.etsi", + IpAddress := "10.10.14.18", + portNumbers := {5090} + }, + { + domainName := "stech.iskratel.etsi", + IpAddress := "10.10.14.6", + portNumbers := {5090} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "astech.iskratel.etsi", + IpAddress := "10.10.14.30", + portNumbers := {5060} + }, + { + domainName := "stech.iskratel.etsi", + IpAddress := "10.10.14.6", + portNumbers := {5090} + } + + } + } + } + } + }, + { + // productIndex = 6 + productName := "Starrent", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.starrent.etsi", + IpAddress := "10.10.15.10", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.10", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.11", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.43", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.44", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.70", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.71", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.108", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.109", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.starrent.etsi", + IpAddress := "10.10.15.10", + portNumbers := {5060} + }, + { + domainName := "scscf.starrent.etsi", + IpAddress := "10.10.15.11", + portNumbers := {5160} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "as.starrent.etsi", + IpAddress := "0.0.0.0", + portNumbers := {5060} + } + } + } + } + } + }, + { + // productIndex = 7 + productName := "Acme Packet", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.acme.etsi", + IpAddress := "10.10.16.40", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.12", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.13", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.47", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.48", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.78", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.79", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.110", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.111", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.acme.etsi", + IpAddress := "10.10.16.40", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "as.acme.etsi", + IpAddress := "0.0.0.0", + portNumbers := {5060} + } + } + } + } + } + }, + { + // productIndex = 8 + productName := "Nexcom", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.nexcom.etsi", + IpAddress := "10.10.7.18", + portNumbers := {5080, 5055} + }, + { + domainName := omit, + IpAddress := "10.10.20.14", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.15", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.49", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.50", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.80", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.81", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.112", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.113", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.nexcom.etsi", + IpAddress := "10.10.7.18", + portNumbers := {5080, 5055} + }, + { + domainName := "icscf.nexcom.etsi", + IpAddress := "10.10.7.18", + portNumbers := {5060} + }, + { + domainName := "scscf.nexcom.etsi", + IpAddress := "10.10.7.18", + portNumbers := {5070} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "as.nexcom.etsi", + IpAddress := "0.0.0.0", + portNumbers := {5060} + } + } + } + } + } + }, + { + // productIndex = 9 + productName := "Hutaro", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.hutaro.etsi", + IpAddress := "10.10.9.26", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.4", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.5", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.45", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.46", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.72", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.73", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.102", + portNumbers := {5060} + }, + { + domainName := omit, + IpAddress := "10.10.20.103", + portNumbers := {5060} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.hutaro.etsi", + IpAddress := "10.10.9.26", + portNumbers := {5060} + }, + { + domainName := "icscf.hutaro.etsi", + IpAddress := "10.10.9.10", + portNumbers := {5080} + }, + { + domainName := "scscf.hutaro.etsi", + IpAddress := "127.0.0.1", + portNumbers := {5090} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "as.hutaro.etsi", + IpAddress := "0.0.0.0", + portNumbers := {5060} + } + } + } + } + } + }, + { + // productIndex = 10 + productName := "Testing Tech IMS Core", + monitorInterfaces := { + { + interfaceName := "Gm", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "pcscf.testingtech.com", + IpAddress := "127.0.0.1", + portNumbers := {5060, 5061} + } + } + } + }, + { + interfaceName := "Ic", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "icscf.testingtech.com", + IpAddress := "127.0.0.1", + portNumbers := {5080} + }, + { + domainName := "scscf.testingtech.com", + IpAddress := "127.0.0.1", + portNumbers := {5090} + } + } + } + }, + { + interfaceName := "Isc", + interfaceInfo := { + IpInterfaceInfo := { + { + domainName := "as.testingtech.com", + IpAddress := "127.0.0.1", + portNumbers := {5060} + } + } + } + } + } + } + } + + /** + * + * @desc Selects product based on index in PX_PRODCUTS vendor list for EUT_A + * + */ + modulepar integer PX_EUT_A := 6; + + /** + * + * @desc Selects product based on index in PX_PRODCUTS vendor list for EUT_B + */ + modulepar integer PX_EUT_B := 8; + + /** + * + * @desc Selects product based on index in PX_PRODCUTS vendor list for EUT_B_B2 + */ + modulepar integer PX_EUT_B_B2 := 2; + + + /** + * + * @desc Selects if interfaces should be considered in the evaluation + * interfaceName needs to be consistent to AtsImsIot_TestConfiguration + */ + modulepar InterfaceAvailableList PX_AVAILABLE_INTERFACES := { + { interfaceName := "Gm A", available := true }, + { interfaceName := "Gm B", available := true }, + { interfaceName := "Ic", available := true }, + { interfaceName := "Isc A", available := true }, + { interfaceName := "Isc B", available := true }, + { interfaceName := "User A", available := true }, + { interfaceName := "User B", available := true }, + { interfaceName := "User A2", available := true }, + { interfaceName := "User B2", available := true } + } + + group adapterGeneralConfiguration { + /** + * + * @desc Maximum time limit used by trigger component for waiting for EUT response after command has been sent + */ + modulepar float PX_EUT_TRIGGER_RESPONSE := 15.0; + + /** + * @desc + * In case of offline mode, it defines the path where all sessions's Pcap files are located. + */ + modulepar charstring PX_IOT_PCAP_SESSIONS_PATH := "c:/Captures/Result/MS2 Wed Afternoon 1"; // Do not forget to upgrade PX_EUT_A and PX_EUT_B + + /** + * @desc + * Defines if the record traffic capture mode must be activated or not. + */ + modulepar RecordMode PX_IOT_RECORD_MODE := e_norecord; + + /** + * @desc + * Defines list of the files to merge. + */ + modulepar FileList PX_IOT_FILE_MERGE_LIST := { "TD_IMS_MESS_0001_19.pcap", "TD_IMS_MESS_0001_20.pcap" }; + + /** + * @desc + * Defines the location of the files to merge. + */ + modulepar charstring PX_IOT_FILE_MERGE_PATH := "."; + + /** + * @desc + * Defines the location of the files to merge. + */ + modulepar charstring PX_IOT_MERGE_TOOL_PATH := "C:\Program Files\WireShark"; + + /** + * @desc + * Defines the time stamp offset to start playing record traffic capture file. + */ + modulepar TimeOffset PX_IOT_TIMESTAMP_OFFSET := + { + seconds := 0, + microseconds := 0 + }; + + /** + * @desc + * List of the network interfaces to monitor. + * Use ';' to separate the interfaces + */ + modulepar charstring PX_IOT_IFACES := "rpcap://\Device\NPF_{9E2D0FCD-C7F5-401D-B736-F0D4F8814715}"; + + modulepar EutInterfaceInfoList PX_IOT_EUTs_IFACE_INFO_LIST := + { + { + eut := "User A", + ipAddress := "127.0.0.1", + portNumber := 6610 + }, + { + eut := "User B", + ipAddress := "127.0.0.1", + portNumber := 6611 + } + }; + + } // group adapterGlobalConfiguration +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_TestConfiguration.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_TestConfiguration.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_TestConfiguration.ttcn (revision 18) @@ -0,0 +1,50 @@ +/* + * @author STF 370 + * @version $Id: LibIot_TestConfiguration.ttcn 16 2009-06-16 15:06:42Z pintar $ + * @desc xxx. + */ + +module LibIot_TestConfiguration { + + import from LibIot_TestInterface { + type + InterfaceMonitor, + IotEquipmentUser, + OracleClient, + OracleServer, + TestCoordinator; + } + + /** + * @desc connects the port of the monitor component to the + * port of the test oracle and activates the default + * @param p_monitor monitor component + */ + function f_cf_oracle_up(in OracleClient p_client) runs on OracleServer { + connect(self:vPort, p_client:vPort); + } + + /** + * @desc deactivates the default and disconnects the port of the monitor + * component + * @param p_monitor monitor component + */ + function f_cf_oracle_down(in OracleClient p_client) runs on OracleServer { + disconnect(self:vPort, p_client:vPort); + } + + /** + * @desc creates a IOT equipment user component + * @param p_name name of the equipment user component + * @return reference to the created equipment user component + */ + function f_cf_create_IotEquipmentUser(in charstring p_name) runs on TestCoordinator return IotEquipmentUser { + var IotEquipmentUser v_iotEquipmentUser := IotEquipmentUser.create(p_name) alive; + // TODO var IotEquipmentUser v_iotEquipmentUser := IotEquipmentUser.create alive; + /* YANN + It's really better to use named port for debug and so on + */ + + return v_iotEquipmentUser; + } +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_TestInterface.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_TestInterface.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_TestInterface.ttcn (revision 18) @@ -0,0 +1,116 @@ +/* + * @author STF 370 + * @version $Id: LibIot_TestInterface.ttcn 16 2009-06-16 15:06:42Z pintar $ + * @desc This module provides the types and components used by the test + * system component for Interoperability tests. + */ + +module LibIot_TestInterface { + + import from LibUpperTester { + type EquipmentOperationReq, EquipmentOperationRsp; + } + + import from LibIot_TypesAndValues all; + + import from LibIot_PIXITS {modulepar PX_MAX_MSG_WAIT;} + + import from LibCommon_Sync all; + import from LibSip_SIPTypesAndValues all; + import from AtsImsIot_TypesAndValues all; + + + group abstractTestComponents { + /** + * @desc + * used to coordinate the behavior of other components. It is in charge + * of controlling the overall execution, manangement of testing phases, + * test verdicts collection and synchronization. Used as MTC. + */ + type component TestCoordinator extends OracleServer { + var ComponentIdList vc_compIds; + port AdapterConfigPort acPort; + } + + /** + * @desc + * collecting information to manage E2E and conformance verdicts. + * Can be used as MTC. + */ + type component OracleServer extends ServerSyncComp { + port VerdictPort vPort; + var VerdictType vc_e3e_verdict := {none, "init"}; + var VerdictType vc_conf_verdict := {none, "init"}; + } + + type component OracleClient extends SelfSyncComp { + port VerdictPort vPort; + } + + /** + * @desc + * This component type is used to monitor interfaces. + * The library provides on the adapter configuration port. + * @remark + * As part of the ATS test system module this component type must be + * extended to include the ATS specific data port! + */ + type component InterfaceMonitor extends OracleClient { + timer tc_wait := PX_MAX_MSG_WAIT; + var charstring vc_interfaceName := "Undefined"; + port AdapterConfigPort acPort; + } + + + /** + * @desc + * This component type is used to trigger, stimualte, configure etc any + * equipment related to the test, i.e., EUTs or other, or the + * interconnecting network. To be used as PTC. + */ + type component EquipmentUser extends OracleClient{ + port EquipmentAccessPort eaPort; + timer T_Equipment; + } + + /** + * @desc This component type is used to trigger, stimulate, configure etc + * any equipment related to the test, i.e., EUTs or other, or + * the interconnecting network. To be used as PTC. + */ + type component IotEquipmentUser extends EquipmentUser { + } + +// TODO commented out due to problems with tools not accepting 'extends' from several components + /** + * @desc This component type is used to trigger, stimulate, configure etc + * any equipment related to the test, i.e., EUTs or other, or + * the interconnecting network. To be used as PTC. + */ +// type component IotEquipmentUser extends EquipmentUser, OracleClient { +// } + + }// end group abstractTestComponents + + group portDefinitions { + + type port EquipmentAccessPort message { + out EquipmentOperationReq; + in EquipmentOperationRsp; + } + type port VerdictPort message { + inout IotVerdict; + } + + type port AdapterConfigPort message { + out GeneralConfigurationReq; + out SetFilterReq; + out StartTrafficCaptureReq; + out StopTrafficCaptureReq; + in GeneralConfigurationRsp; + in SetFilterRsp; + in StartTrafficCaptureRsp; + in StopTrafficCaptureRsp; + } + }// end group portDefinitions +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_TypesAndValues.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_TypesAndValues.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/LibIot/LibIot_TypesAndValues.ttcn (revision 18) @@ -0,0 +1,256 @@ +/* + * @author STF 370 + * @version $Id: LibIot_TypesAndValues.ttcn 16 2009-06-16 15:06:42Z pintar $ + * @desc This module provides the (message) types and constants used by the test component + * for Iot tests. + */ + +module LibIot_TypesAndValues { + + import from LibCommon_BasicTypesAndValues {type UInt32, UInt16;} + + import from LibCommon_VerdictControl {type FncRetCode;} + + group commonTypes { + type enumerated IOTExecMode { e_realtime, e_offline } + + type record Status { + FncRetCode code, + charstring reason optional + } + + } + + group interfaceInformationrelatedTypes { + + /** + * + * @desc IP address type e.g. "127.0.0.1" + */ + type charstring IpAddress; + + /** + * + * @desc Type for port number, e.g. "5060" + */ + type UInt16 PortNumber; + + /** + * + * @desc List of port numbers + */ + type record of PortNumber PortNumberList; + + type record InterfaceAvailable { + charstring interfaceName, + boolean available + } + + type set of InterfaceAvailable InterfaceAvailableList; + + /** + * + * @desc Required information for IP interfaces + * @member domainName the domain name + * @member IpAddress the ip address + * @member portNumbers the list of port numbers where message are received + */ + type record IpInterfaceInfo { + charstring domainName optional, + IpAddress IpAddress, + PortNumberList portNumbers + } + + /** + * + * @desc List of IP interfacees + */ + type record of IpInterfaceInfo IpInterfaceInfoList; + + /** + * + * @desc Collection of different interface types, e.g for IP communications + * This type can be extended with new alternative for other interface types + */ + type union InterfaceInfo { + IpInterfaceInfoList IpInterfaceInfo + } + + /** + * + * @desc Type for representing EUT interface information for monitored logical interfaces + * @member interfaceName Name of logical interface + * @member interfaceInfo Interface information specific to this logical interface + */ + type record MonitorInterfaceInfo { + charstring interfaceName, + InterfaceInfo interfaceInfo + } + + /** + * + * @desc List of monitored interfaces + */ + type record of MonitorInterfaceInfo MonitorInterfaceInfoList; + + /** + * + * @desc Product specific EUT interface information + * @member name the name of the vendor + * @member monitorInterfaces monitor interface configuration + */ + type record Product { + charstring productName, + MonitorInterfaceInfoList monitorInterfaces + } + + /** + * + * @desc List of product specificr EUT interface information + */ + type record of Product ProductList; + } + + + + group adapterConfigurationTypes { + + type union CaptureMode { + LiveCapture liveCpature, + OfflineCapture offlineCapture + } + + // + type record of charstring PhysicalInterfaceList; + + type record LiveCapture { + PhysicalInterfaceList physicalInterfaces, // TODO document example syntax + RecordMode recordMode + } + + type enumerated RecordMode { + e_norecord, + e_record + } + + type record of charstring FileList; + + type record MergeFileList { + FileList mergeFileList, + charstring mergeFilePath, + charstring mergeToolPath + } + + type record CaptureSource { + charstring sessionsPath, // e.g., the path where session's PCAP files are located like /tmp/19 + MergeFileList mergeFileList + } + + type record TimeOffset + { + UInt32 seconds, + UInt32 microseconds + } + + type record OfflineCapture { + TimeOffset offset, + CaptureSource captureSource + } + + /** + * + * @desc Required information for EUTs IP interfaces + * @member IpAddress the ip address + * @member portNumber the list of port number where message are received + */ + type record EutInterfaceInfo { + charstring eut, + IpAddress ipAddress, + PortNumber portNumber + } + + /** + * + * @desc List of IP interfaces for EUTs + */ + type record of EutInterfaceInfo EutInterfaceInfoList; + + + + type record GeneralConfigurationReq { + charstring captureProcessIpAddress, + PortNumber captureProcessPort, + CaptureMode captureMode, + EutInterfaceInfoList eutInfoList optional + } + + type record GeneralConfigurationRsp + { + Status status + } + + + //type record (2..infinity) of InterfaceInfo InterfaceInfoList; + type record of InterfaceInfo InterfaceInfoList; + + type enumerated ProtocolFilter { + e_sip, + e_dns + } + + type record SetFilterReq { + ProtocolFilter protocol, + InterfaceInfoList interfaceInfos + } + + + type record SetFilterRsp + { + Status status + } + + + type record StartTrafficCaptureReq { } + + type record StartTrafficCaptureRsp + { + Status status + } + + + type record StopTrafficCaptureReq { } + + type record StopTrafficCaptureRsp + { + Status status + } + + } + + group oracleRelatedTypes { + // used for PIXIT definition + type enumerated IotVerdictType { e_e2e, e_conformance } + + // used for verdict handling + type record VerdictType { + verdicttype verdict, + charstring reason optional + } + + type union IotVerdict { + VerdictType e2e, + VerdictType conformance + } + } + /** + * @desc Default record + */ + type record of default DefaultList; + + type record ComponentId { + charstring name, + integer index // explain more + } + + type set of ComponentId ComponentIdList; +} Index: trunk/ETSI-Testsuites/ETSI_auto_IOT/LibUpperTester/LibUpperTester.ttcn =================================================================== --- trunk/ETSI-Testsuites/ETSI_auto_IOT/LibUpperTester/LibUpperTester.ttcn (revision 18) +++ trunk/ETSI-Testsuites/ETSI_auto_IOT/LibUpperTester/LibUpperTester.ttcn (revision 18) @@ -0,0 +1,57 @@ +/* + * @author STF 370 + * @version $Id$ + * @desc xxx + */ +module LibUpperTester { + import from LibCommon_VerdictControl {type FncRetCode;} + import from LibIot_TypesAndValues {type Status;} + + // TODO - move to common lib + /*type record Status { + FncRetCode code, charstring reason optional + }*/ +// TODO commented out due to problems with tools not accepting 'extends' from several components + /** + * @desc + * This component type is used to trigger, stimualte, configure etc any + * equipment related to the test, i.e., EUTs or other, or the + * interconnecting network. To be used as PTC. + */ +// type component EquipmentUser { +// port EquipmentAccessPort eaPort; +// timer T_Equipment; +// } + + group equipmentOperationTypes { + + type record of charstring ParameterList; + + type charstring EquipmentCommand; + + type record EquipmentOperationReq { + EquipmentCommand cmd, ParameterList params optional + } + + type record EquipmentOperationRsp { + Status status + } + } + + group equipmentOperationTemplates { + + template EquipmentOperationReq m_EQ_Request(in EquipmentCommand p_cmd, ParameterList p_params) := { + cmd := p_cmd, + params := p_params + } + + template EquipmentOperationRsp mw_EO_Response(in template FncRetCode p_code) := { + status := { + code := p_code, + reason := * + } + } + } + + +}