Context Navigation

AtsImsIot_TestConfiguration.ttcn @ 18

Last change on this file since 18 was 18, checked in by phdmakk, 14 years ago

File size: 29.7 KB

Rev	Line
[18]	1	/*
	2	* @author STF 370
	3	* @version $Id $
	4	* @desc This module contains functions which implement the
	5	* configuration of the SUT adapter and mapping of test
	6	* components for establishing and tearing down different
	7	* test configurations.
	8	*/
	9
	10	module AtsImsIot_TestConfiguration {
	11
	12	import from LibIms_UpperTester language "TTCN-3:2008 Amendment 1" {
	13	modulepar PX_IMS_USER_DATA;
	14	}
	15
	16	import from LibIot_TypesAndValues {
	17	type StartTrafficCaptureRsp, StopTrafficCaptureRsp;
	18	}
	19
	20	import from AtsImsIot_TestSystem {type CF_INT_CALL, CF_INT_AS, CF_ROAM_AS;}
	21
	22	import from LibIot_PIXITS {
	23	modulepar PX_EUT_A, PX_EUT_B, PX_PRODUCTS, PX_MAX_MSG_WAIT;
	24	}
	25
	26	import from LibIot_Functions language "TTCN-3:2008 Amendment 1" {
	27	altstep a_receiveIOTVerdict;
	28	function f_setConformanceVerdict, f_setE2EVerdict;
	29	}
	30
	31	import from AtsImsIot_Templates {
	32	template
	33	m_generalConfigurationReq_offline,
	34	m_generalConfigurationReq_online,
	35	m_generalConfigurationReq_merge,
	36	m_generalConfigurationRsp_success,
	37	m_generalConfigurationRsp_error,
	38	m_generalConfigurationRsp_timeout,
	39	m_SetFilterReq,
	40	mw_SetFilterRsp,
	41	m_startTrafficCaptureReq,
	42	m_stopTrafficCaptureReq,
	43	m_startTrafficCaptureRsp_any,
	44	m_stopTrafficCaptureRsp_any;
	45	}
	46
	47	import from LibCommon_VerdictControl {type FncRetCode;}
	48
	49	import from LibIot_TypesAndValues {
	50	type
	51	InterfaceInfo,
	52	InterfaceInfoList,
	53	Product,
	54	ProtocolFilter,
	55	StartTrafficCaptureRsp,
	56	StopTrafficCaptureRsp,
	57	SetFilterReq,
	58	SetFilterRsp,
	59	Status;
	60	}
	61
	62	import from LibIot_TestConfiguration {
	63	function f_cf_oracle_up, f_cf_oracle_down;
	64	}
	65
	66	import from AtsImsIot_TestSystem {
	67	type ImsInterfaceMonitor, ImsTestCoordinator;
	68	}
	69
	70	import from LibIot_TestInterface {type IotEquipmentUser;}
	71
	72	import from AtsImsIot_Functions {function f_setInterfaceNameOnComponent;}
	73
	74
	75	group constantDefinitions {
	76	//* interface monitor name Gm A
	77	const charstring c_gm_A := "Gm A";
	78	//* interface monitor name Gm B
	79	const charstring c_gm_B := "Gm B";
	80	//* interface monitor name Mx A
	81	const charstring c_mx_A := "Mx A";
	82	//* interface monitor name Mx B
	83	const charstring c_mx_B := "Mx B";
	84	//* interface monitor name Ic
	85	const charstring c_ic := "Ic";
	86	//* interface monitor name Isc A
	87	const charstring c_isc_A := "Isc A";
	88	//* interface monitor name Isc B
	89	const charstring c_isc_B := "Isc B";
	90	//* eut trigger name User A
	91	const charstring c_trigger_A := "User A";
	92	//* eut trigger name User B
	93	const charstring c_trigger_B := "User B";
	94	//* eut trigger name User A
	95	const charstring c_userUE_A := "User A";
	96	const charstring c_userUE_A2 := "User A2";
	97	//* eut trigger name User B
	98	const charstring c_userUE_B := "User B";
	99	const charstring c_userUE_B2 := "User B2";
	100	}
	101
	102	group mappingFunctions {
	103
	104	/**
	105	*
	106	* @desc initialize the adapter port of MTC
	107	*/
	108	function f_cf_adapter_up() runs on ImsTestCoordinator {
	109	map(self:acPort, system:acPort);
	110	}
	111
	112	/**
	113	*
	114	* @desc uninitialize the adapter port of MTC
	115	*/
	116	function f_cf_adapter_down() runs on ImsTestCoordinator {
	117	unmap(self:acPort, system:acPort);
	118	}
	119
	120	/**
	121	*
	122	* @desc initialize trigger component ports
	123	* @param p_driver trigger component
	124	*/
	125	function f_cf_user_up(in IotEquipmentUser p_driver) runs on ImsTestCoordinator {
	126	// connect sync ports
	127	connect(p_driver:syncPort, self:syncPort);
	128	// connect TSI ports
	129	map(p_driver:eaPort, system:eaPort);
	130	// configure oracle
	131	f_cf_oracle_up(p_driver);
	132	}
	133
	134	/**
	135	*
	136	* @desc uninitialize trigger component ports
	137	* @param p_driver trigger component
	138	*/
	139	function f_cf_user_down(in IotEquipmentUser p_driver) runs on ImsTestCoordinator {
	140	// disconnect sync ports
	141	disconnect(p_driver:syncPort, self:syncPort);
	142	// disconnect TSI ports
	143	unmap(p_driver:eaPort, system:eaPort);
	144	// release oracle ports
	145	f_cf_oracle_down(p_driver);
	146	}
	147
	148	/**
	149	* @desc configures monitor component: connects to the synchronnization
	150	* port, maps to the TSI port and connects to the oracle
	151	* @param p_monitor monitor component
	152	*/
	153	function f_cf_monitor_up(in ImsInterfaceMonitor p_monitor) runs on ImsTestCoordinator {
	154	// connect sync ports
	155	connect(p_monitor:syncPort, self:syncPort);
	156	connect(p_monitor:icpPort, self:icpPort);
	157	// mapp TSI port
	158	map(p_monitor:dPort, system:dPort);
	159	map(p_monitor:acPort, system:acPort);
	160	// configure oracle
	161	f_cf_oracle_up(p_monitor);
	162	}
	163
	164	/**
	165	* @desc frees monitor component: disconnects the synchronnization
	166	* port, unmaps from the TSI port and disconnects from the oracle
	167	* @param p_monitor monitor component
	168	*/
	169	function f_cf_monitor_down(in ImsInterfaceMonitor p_monitor) runs on ImsTestCoordinator {
	170	// connect sync ports
	171	disconnect(p_monitor:syncPort, self:syncPort);
	172	disconnect(p_monitor:icpPort, self:icpPort);
	173	// mapp TSI port
	174	unmap(p_monitor:dPort, system:dPort);
	175	unmap(p_monitor:acPort, system:acPort);
	176	// configure oracle
	177	f_cf_oracle_down(p_monitor);
	178	}
	179
	180	}
	181
	182	group adapterConfiguration {
	183
	184	function f_cf_setFilter(in SetFilterReq p_req) runs on ImsInterfaceMonitor {
	185	var SetFilterRsp v_rsp;
	186	var template Status v_status := {
	187	code := e_success,
	188	reason := *
	189	}
	190
	191	tc_wait.start;
	192	acPort.send(p_req);
	193	alt {
	194	[] acPort.receive (mw_SetFilterRsp(v_status)) -> value v_rsp {
	195	tc_wait.stop;
	196	f_setE2EVerdict(pass, "Adapter Configuration: setting monitor filter successful");
	197	f_setConformanceVerdict(pass, "Adapter Configuration: setting monitor filter successful");
	198	}
	199	[] acPort.receive (mw_SetFilterRsp(?)) -> value v_rsp {
	200	tc_wait.stop;
	201	f_setE2EVerdict(inconc, "Adapter Configuration: error while setting monitor filter");
	202	f_setConformanceVerdict(inconc, "Adapter Configuration: error while setting monitor filter");
	203	}
	204	[] tc_wait.timeout {
	205	f_setE2EVerdict(inconc, "Adapter Configuration: timer expires while waiting for response");
	206	f_setConformanceVerdict(inconc, "Adapter Configuration: timer expires while waiting for response");
	207	}
	208	}
	209	}
	210
	211
	212	}
	213
	214	group componentCreation {
	215
	216	/**
	217	* @desc creates a monitor component
	218	* @param p_name name of the monitor component
	219	* @return the created monitor component
	220	*/
	221	function f_cf_create_monitor(in charstring p_name) runs on ImsTestCoordinator return ImsInterfaceMonitor {
	222	var ImsInterfaceMonitor v_monitor := ImsInterfaceMonitor.create(p_name) alive;
	223	v_monitor.start(f_setInterfaceNameOnComponent(p_name));
	224	v_monitor.done;
	225	return v_monitor;
	226	}
	227	}
	228
	229
	230	group testConfiguration {
	231
	232	/**
	233	* @desc
	234	* Test configuration function for roaming registration szenario.
	235	* More information can be found in ETSI TS 186 011-2 V2.3.1 Cause
	236	* 4.3.4.
	237	* @param p_Gm Gm interface monitor component
	238	* @param p_ic Mw interface monitor component
	239	*/
	240	function f_cf_roam_reg_up(
	241	inout ImsInterfaceMonitor p_Gm,
	242	inout ImsInterfaceMonitor p_ic
	243	) runs on ImsTestCoordinator {
	244	// Initialize the Adapter (including the TrafficCapture process).
	245	timer tc_configureGuard;
	246	var StartTrafficCaptureRsp startResult;
	247	activate(a_receiveIOTVerdict());
	248
	249	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	250	acPort.send(m_generalConfigurationReq_offline);
	251	alt {
	252	[] acPort.receive (m_generalConfigurationRsp_success) {
	253	log("General configuration succeed.");
	254	tc_configureGuard.stop;
	255	}
	256	[] acPort.receive (m_generalConfigurationRsp_timeout) {
	257	setverdict(fail);
	258	tc_configureGuard.stop;
	259	stop;
	260	}
	261	[] acPort.receive (m_generalConfigurationRsp_error) {
	262	setverdict(fail);
	263	tc_configureGuard.stop;
	264	stop;
	265	}
	266	[] acPort.receive {
	267	log("Unknown response.");
	268	tc_configureGuard.stop;
	269	setverdict (inconc);
	270	stop;
	271	}
	272	[] tc_configureGuard.timeout {
	273	log("Timeout.");
	274	setverdict (inconc);
	275	stop;
	276	}
	277	}
	278
	279	f_cf_monitor_up(p_Gm);
	280	f_cf_monitor_up(p_ic);
	281
	282	// TODO UE IP address and port is missing
	283	p_Gm.start(f_cf_setFilter(
	284	valueof (m_SetFilterReq(
	285	e_sip,
	286	f_getInterfaceInfoList("Gm", PX_EUT_A, PX_EUT_B)
	287	)
	288	)));
	289	p_Gm.done;
	290
	291	p_ic.start(f_cf_setFilter(
	292	valueof(m_SetFilterReq(
	293	e_sip,
	294	f_getInterfaceInfoList("Ic", PX_EUT_A, PX_EUT_B)
	295	)
	296	)));
	297	p_ic.done;
	298
	299	// Start traffic capture processing.
	300	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	301	acPort.send(m_startTrafficCaptureReq);
	302	alt {
	303	[] acPort.receive (m_startTrafficCaptureRsp_any) -> value startResult {
	304	tc_configureGuard.stop;
	305	if (startResult.status.code != e_success)
	306	{
	307	log("** StartTrafficCaptureReq unsuccessfull! **");
	308	setverdict(fail);
	309	stop;
	310	}
	311	}
	312	[] tc_configureGuard.timeout {
	313	log("** StartTrafficCaptureReq not answered. **");
	314	setverdict (inconc);
	315	stop;
	316	}
	317	}
	318	}
	319
	320	/**
	321	* @desc
	322	* Test configuration function for roaming registration szenario.
	323	* More information can be found in ETSI TS 186 011-2 V2.3.1 Cause
	324	* 4.3.4.
	325	* @param p_Gm Gm interface monitor component
	326	* @param p_ic Mw interface monitor component
	327	*/
	328	function f_cf_roam_reg_down(
	329	inout ImsInterfaceMonitor p_Gm,
	330	inout ImsInterfaceMonitor p_ic
	331	) runs on ImsTestCoordinator {
	332	// Stop traffic capture processing.
	333	timer tc_configureGuard;
	334	var StopTrafficCaptureRsp stopResult;
	335	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	336	acPort.send(m_stopTrafficCaptureReq);
	337	alt {
	338	[] acPort.receive (m_stopTrafficCaptureRsp_any) -> value stopResult {
	339	tc_configureGuard.stop;
	340	if (stopResult.status.code != e_success)
	341	{
	342	log("** TC_IMS_MESS_0001: StopTrafficCaptureReq unsuccessfull! **");
	343	setverdict(fail);
	344	}
	345	}
	346	[] tc_configureGuard.timeout {
	347	log("** TC_IMS_MESS_0001: StopTrafficCaptureReq not answered. **");
	348	setverdict (inconc);
	349	}
	350	}
	351	f_cf_monitor_down(p_Gm);
	352	f_cf_monitor_down(p_ic);
	353	}
	354
	355	/**
	356	* @desc
	357	* Interworking Call test configuration. Mapps/connects all related
	358	* ports and initialize the test adapter.
	359	* More information can be found in ETSI TS 186 011-2 V2.3.1 Cause
	360	* 4.3.4.
	361	* @param p_GmA Gm A Interface Monitor component
	362	* @param p_ic Mw Interface Monitor component
	363	* @param p_GmB
	364	* Gm B Interface Monitor component (optional, can be omitted)
	365	*/
	366	function f_cf_int_call_up(
	367	inout CF_INT_CALL p_config
	368	) runs on ImsTestCoordinator {
	369	// Initialize the Adapter (including the TrafficCapture process).
	370	timer tc_configureGuard;
	371	var StartTrafficCaptureRsp startResult;
	372
	373	activate(a_receiveIOTVerdict());
	374
	375	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	376	acPort.send(m_generalConfigurationReq_offline);
	377	alt {
	378	[] acPort.receive (m_generalConfigurationRsp_success) {
	379	log("General configuration succeed.");
	380	tc_configureGuard.stop;
	381	}
	382	[] acPort.receive (m_generalConfigurationRsp_timeout) {
	383	setverdict(fail);
	384	tc_configureGuard.stop;
	385	stop;
	386	}
	387	[] acPort.receive (m_generalConfigurationRsp_error) {
	388	setverdict(fail);
	389	tc_configureGuard.stop;
	390	stop;
	391	}
	392	[] acPort.receive {
	393	log("Unknown response.");
	394	tc_configureGuard.stop;
	395	setverdict (inconc);
	396	stop;
	397	}
	398	[] tc_configureGuard.timeout {
	399	log("Timeout.");
	400	setverdict (inconc);
	401	stop;
	402	}
	403	}
	404
	405	f_cf_monitor_up(p_config.gmA);
	406	f_cf_monitor_up(p_config.mw);
	407	if(isvalue(p_config.gmB)) {
	408	f_cf_monitor_up(p_config.gmB);
	409	}
	410
	411	// TODO UE IP address and port is missing
	412	p_config.gmA.start(f_cf_setFilter(
	413	valueof (m_SetFilterReq(
	414	e_sip,
	415	{f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_A])}
	416	)
	417	)));
	418	p_config.gmA.done;
	419
	420	p_config.mw.start(f_cf_setFilter(
	421	valueof(m_SetFilterReq(
	422	e_sip,
	423	f_getInterfaceInfoList("Ic", PX_EUT_A, PX_EUT_B)
	424	)
	425	)));
	426	p_config.mw.done;
	427
	428	if(isvalue(p_config.gmB)) {
	429	p_config.gmB.start(f_cf_setFilter(
	430	valueof (m_SetFilterReq(
	431	e_sip,
	432	{f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_B])}
	433	)
	434	)));
	435	p_config.gmB.done;
	436	}
	437	// Start traffic capture processing.
	438	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	439	acPort.send(m_startTrafficCaptureReq);
	440	alt {
	441	[] acPort.receive (m_startTrafficCaptureRsp_any) -> value startResult {
	442	tc_configureGuard.stop;
	443	if (startResult.status.code != e_success)
	444	{
	445	log("** StartTrafficCaptureReq unsuccessfull! **");
	446	setverdict(fail);
	447	stop;
	448	}
	449	}
	450	[] tc_configureGuard.timeout {
	451	log("** StartTrafficCaptureReq not answered. **");
	452	setverdict (inconc);
	453	stop;
	454	}
	455	}
	456	}
	457
	458	/**
	459	* @desc
	460	* Interworking Call test configuration. Ummaps/disconnect the
	461	* related component ports. More information can be found in ETSI TS
	462	* 186 011-2 V2.3.1 Cause 4.3.4.
	463	* @param p_GmA Gm A Interface Monitor component
	464	* @param p_ic Mw Interface Monitor component
	465	* @param p_GmB
	466	* Gm B Interface Monitor component (optional, can be omitted)
	467	*/
	468	function f_cf_int_call_down(
	469	inout CF_INT_CALL p_config
	470	) runs on ImsTestCoordinator {
	471	// Stop traffic capture processing.
	472	timer tc_configureGuard;
	473	var StopTrafficCaptureRsp stopResult;
	474	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	475	acPort.send(m_stopTrafficCaptureReq);
	476	alt {
	477	[] acPort.receive (m_stopTrafficCaptureRsp_any) -> value stopResult {
	478	tc_configureGuard.stop;
	479	if (stopResult.status.code != e_success)
	480	{
	481	log("** TC_IMS_MESS_0001: StopTrafficCaptureReq unsuccessfull! **");
	482	setverdict(fail);
	483	}
	484	}
	485	[] tc_configureGuard.timeout {
	486	log("** TC_IMS_MESS_0001: StopTrafficCaptureReq not answered. **");
	487	//setverdict (inconc);
	488	}
	489	}
	490	f_cf_monitor_down(p_config.gmA);
	491	f_cf_monitor_down(p_config.mw);
	492	if(isvalue(p_config.gmB)) {
	493	f_cf_monitor_down(p_config.gmB);
	494	}
	495	}
	496
	497	/**
	498	* @desc
	499	* Roaming Call test configuration. Mapps/connects all related
	500	* ports and initialize the test adapter.
	501	* More information can be found in ETSI TS 186 011-2 V2.3.1 Cause
	502	* 4.3.4.
	503	* @param p_Gm Gm A Interface Monitor component
	504	* @param p_ic Mw Interface Monitor component
	505	*/
	506	function f_cf_roam_call_up(
	507	inout ImsInterfaceMonitor p_Gm,
	508	inout ImsInterfaceMonitor p_ic
	509	) runs on ImsTestCoordinator {
	510	// Initialize the Adapter (including the TrafficCapture process).
	511	timer tc_configureGuard;
	512	var StartTrafficCaptureRsp startResult;
	513	activate(a_receiveIOTVerdict());
	514	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	515	acPort.send(m_generalConfigurationReq_offline);
	516	alt {
	517	[] acPort.receive (m_generalConfigurationRsp_success) {
	518	log("General configuration succeed.");
	519	tc_configureGuard.stop;
	520	}
	521	[] acPort.receive (m_generalConfigurationRsp_timeout) {
	522	setverdict(fail);
	523	tc_configureGuard.stop;
	524	stop;
	525	}
	526	[] acPort.receive (m_generalConfigurationRsp_error) {
	527	setverdict(fail);
	528	tc_configureGuard.stop;
	529	stop;
	530	}
	531	[] acPort.receive {
	532	log("Unknown response.");
	533	tc_configureGuard.stop;
	534	setverdict (inconc);
	535	stop;
	536	}
	537	[] tc_configureGuard.timeout {
	538	log("Timeout.");
	539	setverdict (inconc);
	540	stop;
	541	}
	542	}
	543
	544	f_cf_monitor_up(p_Gm);
	545	f_cf_monitor_up(p_ic);
	546
	547	// TODO UE IP address and port is missing
	548	// TODO UE IP address and port is missing
	549	p_Gm.start(f_cf_setFilter(
	550	valueof (m_SetFilterReq(
	551	e_sip,
	552	f_getInterfaceInfoList("Gm", PX_EUT_A, PX_EUT_B)
	553	)
	554	)));
	555	p_Gm.done;
	556
	557	p_ic.start(f_cf_setFilter(
	558	valueof(m_SetFilterReq(
	559	e_sip,
	560	f_getInterfaceInfoList("Ic", PX_EUT_A, PX_EUT_B)
	561	)
	562	)));
	563	p_ic.done;
	564
	565	// Start traffic capture processing.
	566	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	567	acPort.send(m_startTrafficCaptureReq);
	568	alt {
	569	[] acPort.receive (m_startTrafficCaptureRsp_any) -> value startResult {
	570	tc_configureGuard.stop;
	571	if (startResult.status.code != e_success)
	572	{
	573	log("** StartTrafficCaptureReq unsuccessfull! **");
	574	setverdict(fail);
	575	stop;
	576	}
	577	}
	578	[] tc_configureGuard.timeout {
	579	log("** StartTrafficCaptureReq not answered. **");
	580	setverdict (inconc);
	581	stop;
	582	}
	583	}
	584	}
	585
	586	/**
	587	* @desc
	588	* Roaming Call test configuration. Ummaps/disconnect the
	589	* related component ports. More information can be found in ETSI TS
	590	* 186 011-2 V2.3.1 Cause 4.3.4.
	591	* @param p_GmA Gm A Interface Monitor component
	592	* @param p_ic Mw Interface Monitor component
	593	*/
	594	function f_cf_roam_call_down(
	595	inout ImsInterfaceMonitor p_GmA,
	596	inout ImsInterfaceMonitor p_ic
	597	) runs on ImsTestCoordinator {
	598	// Stop traffic capture processing.
	599	timer tc_configureGuard;
	600	var StopTrafficCaptureRsp stopResult;
	601	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	602	acPort.send(m_stopTrafficCaptureReq);
	603	alt {
	604	[] acPort.receive (m_stopTrafficCaptureRsp_any) -> value stopResult {
	605	tc_configureGuard.stop;
	606	if (stopResult.status.code != e_success)
	607	{
	608	log("** TC_IMS_MESS_0001: StopTrafficCaptureReq unsuccessfull! **");
	609	setverdict(fail);
	610	}
	611	}
	612	[] tc_configureGuard.timeout {
	613	log("** TC_IMS_MESS_0001: StopTrafficCaptureReq not answered. **");
	614	setverdict (inconc);
	615	}
	616	}
	617	f_cf_monitor_down(p_GmA);
	618	f_cf_monitor_down(p_ic);
	619	}
	620
	621
	622	/**
	623	* @desc
	624	* Roaming Call test configuration. Mapps/connects all related
	625	* ports and initialize the test adapter.
	626	* More information can be found in ETSI TS 186 011-2 V2.3.1 Cause
	627	* 4.3.4.
	628	* @param p_config.gmA Gm A Interface Monitor component
	629	* @param p_config.mw Mw Interface Monitor component
	630	* @param p_config.gmB Gm B Interface Monitor component
	631	* @param p_config.iscA Isc A Interface Monitor component
	632	* @param p_config.iscB Isc B Interface Monitor component
	633	* IscA and IscB Interface Monitor component (optional, can be omitted)
	634	*/
	635	function f_cf_int_as_up(
	636	inout CF_INT_AS p_config
	637	) runs on ImsTestCoordinator {
	638	// Initialize the Adapter (including the TrafficCapture process).
	639	timer tc_configureGuard;
	640	var StartTrafficCaptureRsp startResult;
	641	activate(a_receiveIOTVerdict());
	642	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	643	acPort.send(m_generalConfigurationReq_offline);
	644	alt {
	645	[] acPort.receive (m_generalConfigurationRsp_success) {
	646	log("General configuration succeed.");
	647	tc_configureGuard.stop;
	648	}
	649	[] acPort.receive (m_generalConfigurationRsp_timeout) {
	650	setverdict(fail);
	651	tc_configureGuard.stop;
	652	stop;
	653	}
	654	[] acPort.receive (m_generalConfigurationRsp_error) {
	655	setverdict(fail);
	656	tc_configureGuard.stop;
	657	stop;
	658	}
	659	[] acPort.receive {
	660	log("Unknown response.");
	661	tc_configureGuard.stop;
	662	setverdict (inconc);
	663	stop;
	664	}
	665	[] tc_configureGuard.timeout {
	666	log("Timeout.");
	667	setverdict (inconc);
	668	stop;
	669	}
	670	}
	671
	672	f_cf_monitor_up(p_config.gmA);
	673	f_cf_monitor_up(p_config.mw);
	674	f_cf_monitor_up(p_config.gmB);
	675	if(isvalue(p_config.iscA)) {
	676	f_cf_monitor_up(p_config.iscA);
	677	}
	678	if(isvalue(p_config.iscB)) {
	679	f_cf_monitor_up(p_config.iscB);
	680	}
	681
	682	// TODO UE IP address and port is missing
	683	p_config.gmA.start(f_cf_setFilter(
	684	valueof (m_SetFilterReq(
	685	e_sip,
	686	{f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_A])}
	687	)
	688	)));
	689	p_config.gmA.done;
	690
	691	p_config.mw.start(f_cf_setFilter(
	692	valueof(m_SetFilterReq(
	693	e_sip,
	694	f_getInterfaceInfoList("Ic", PX_EUT_A, PX_EUT_B)
	695	)
	696	)));
	697	p_config.mw.done;
	698
	699	p_config.gmB.start(f_cf_setFilter(
	700	valueof (m_SetFilterReq(
	701	e_sip,
	702	{f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_B])}
	703	)
	704	)));
	705	p_config.gmB.done;
	706
	707	if(isvalue(p_config.iscA)) {
	708	p_config.iscA.start(f_cf_setFilter(
	709	valueof (m_SetFilterReq(
	710	e_sip,
	711	{f_getInterfaceInfo("Isc", PX_PRODUCTS[PX_EUT_A])}
	712	)
	713	)));
	714	p_config.iscA.done;
	715	}
	716
	717	if(isvalue(p_config.iscB)) {
	718	p_config.iscB.start(f_cf_setFilter(
	719	valueof (m_SetFilterReq(
	720	e_sip,
	721	{f_getInterfaceInfo("Isc", PX_PRODUCTS[PX_EUT_B])}
	722	)
	723	)));
	724	p_config.iscB.done;
	725	}
	726
	727	// Start traffic capture processing.
	728	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	729	acPort.send(m_startTrafficCaptureReq);
	730	alt {
	731	[] acPort.receive (m_startTrafficCaptureRsp_any) -> value startResult {
	732	tc_configureGuard.stop;
	733	if (startResult.status.code != e_success)
	734	{
	735	log("** StartTrafficCaptureReq unsuccessfull! **");
	736	setverdict(fail);
	737	stop;
	738	}
	739	}
	740	[] tc_configureGuard.timeout {
	741	log("** StartTrafficCaptureReq not answered. **");
	742	setverdict (inconc);
	743	stop;
	744	}
	745	}
	746	}
	747
	748	/**
	749	* @desc
	750	* Interworking Application Server test configuration.
	751	* Ummaps/disconnect the related component ports. More information
	752	* can be found in ETSI TS 186 011-2 V2.3.1 Cause 4.3.4.
	753	* @param p_config.gmA Gm A Interface Monitor component
	754	* @param p_config.mw Mw Interface Monitor component
	755	* @param p_config.gmB Gm B Interface Monitor component
	756	* @param p_config.iscA Isc A Interface Monitor component
	757	* @param p_config.iscB Isc B Interface Monitor component
	758	* IscA and IscB Interface Monitor component (optional, can be omitted)
	759	*/
	760	function f_cf_int_as_down(
	761	inout CF_INT_AS p_config
	762	) runs on ImsTestCoordinator {
	763	// Stop traffic capture processing.
	764	timer tc_configureGuard;
	765	var StopTrafficCaptureRsp stopResult;
	766	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	767	acPort.send(m_stopTrafficCaptureReq);
	768	alt {
	769	[] acPort.receive (m_stopTrafficCaptureRsp_any) -> value stopResult {
	770	tc_configureGuard.stop;
	771	if (stopResult.status.code != e_success)
	772	{
	773	log("** TC_IMS_MESS_0001: StopTrafficCaptureReq unsuccessfull! **");
	774	setverdict(fail);
	775	}
	776	}
	777	[] tc_configureGuard.timeout {
	778	log("** TC_IMS_MESS_0001: StopTrafficCaptureReq not answered. **");
	779	//setverdict (inconc);
	780	}
	781	}
	782	f_cf_monitor_down(p_config.gmA);
	783	f_cf_monitor_down(p_config.mw);
	784	f_cf_monitor_down(p_config.gmB);
	785	if(isvalue(p_config.iscA)) {
	786	f_cf_monitor_down(p_config.iscA);
	787	}
	788	if(isvalue(p_config.iscB)) {
	789	f_cf_monitor_down(p_config.iscB);
	790	}
	791	}
	792
	793
	794	/**
	795	* @desc
	796	* Roaming Call test configuration. Mapps/connects all related
	797	* ports and initialize the test adapter.
	798	* More information can be found in ETSI TS 186 011-2 V2.3.1 Cause
	799	* 4.3.4.
	800	* @param p_config.gmA Gm A Interface Monitor component
	801	* @param p_config.mw Mw Interface Monitor component
	802	* @param p_config.gmB Gm B Interface Monitor component
	803	* @param p_config.iscA Isc A Interface Monitor component
	804	* @param p_config.iscB Isc B Interface Monitor component
	805	* IscA and IscB Interface Monitor component (optional, can be omitted)
	806	*/
	807	function f_cf_roam_as_up(
	808	inout CF_ROAM_AS p_config
	809	) runs on ImsTestCoordinator {
	810	// Initialize the Adapter (including the TrafficCapture process).
	811	timer tc_configureGuard;
	812	var StartTrafficCaptureRsp startResult;
	813	activate(a_receiveIOTVerdict());
	814	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	815	acPort.send(m_generalConfigurationReq_offline);
	816	alt {
	817	[] acPort.receive (m_generalConfigurationRsp_success) {
	818	log("General configuration succeed.");
	819	tc_configureGuard.stop;
	820	}
	821	[] acPort.receive (m_generalConfigurationRsp_timeout) {
	822	setverdict(fail);
	823	tc_configureGuard.stop;
	824	stop;
	825	}
	826	[] acPort.receive (m_generalConfigurationRsp_error) {
	827	setverdict(fail);
	828	tc_configureGuard.stop;
	829	stop;
	830	}
	831	[] acPort.receive {
	832	log("Unknown response.");
	833	tc_configureGuard.stop;
	834	setverdict (inconc);
	835	stop;
	836	}
	837	[] tc_configureGuard.timeout {
	838	log("Timeout.");
	839	setverdict (inconc);
	840	stop;
	841	}
	842	}
	843
	844	f_cf_monitor_up(p_config.gmA);
	845	f_cf_monitor_up(p_config.mw);
	846	f_cf_monitor_up(p_config.gmB);
	847	if(isvalue(p_config.iscA)) {
	848	f_cf_monitor_up(p_config.iscA);
	849	}
	850	if(isvalue(p_config.iscB)) {
	851	f_cf_monitor_up(p_config.iscB);
	852	}
	853
	854	// TODO UE IP address and port is missing
	855	p_config.gmA.start(f_cf_setFilter(
	856	valueof (m_SetFilterReq(
	857	e_sip,
	858	{f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_A])}
	859	)
	860	)));
	861	p_config.gmA.done;
	862
	863	p_config.mw.start(f_cf_setFilter(
	864	valueof(m_SetFilterReq(
	865	e_sip,
	866	f_getInterfaceInfoList("Ic", PX_EUT_A, PX_EUT_B)
	867	)
	868	)));
	869	p_config.mw.done;
	870
	871	p_config.gmB.start(f_cf_setFilter(
	872	valueof (m_SetFilterReq(
	873	e_sip,
	874	{f_getInterfaceInfo("Gm", PX_PRODUCTS[PX_EUT_B])}
	875	)
	876	)));
	877	p_config.gmB.done;
	878
	879	if(isvalue(p_config.iscA)) {
	880	p_config.iscA.start(f_cf_setFilter(
	881	valueof (m_SetFilterReq(
	882	e_sip,
	883	{f_getInterfaceInfo("Isc", PX_PRODUCTS[PX_EUT_A])}
	884	)
	885	)));
	886	p_config.iscA.done;
	887	}
	888
	889	if(isvalue(p_config.iscB)) {
	890	p_config.iscB.start(f_cf_setFilter(
	891	valueof (m_SetFilterReq(
	892	e_sip,
	893	{f_getInterfaceInfo("Isc", PX_PRODUCTS[PX_EUT_B])}
	894	)
	895	)));
	896	p_config.iscB.done;
	897	}
	898
	899	// Start traffic capture processing.
	900	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	901	acPort.send(m_startTrafficCaptureReq);
	902	alt {
	903	[] acPort.receive (m_startTrafficCaptureRsp_any) -> value startResult {
	904	tc_configureGuard.stop;
	905	if (startResult.status.code != e_success)
	906	{
	907	log("** StartTrafficCaptureReq unsuccessfull! **");
	908	setverdict(fail);
	909	stop;
	910	}
	911	}
	912	[] tc_configureGuard.timeout {
	913	log("** StartTrafficCaptureReq not answered. **");
	914	setverdict (inconc);
	915	stop;
	916	}
	917	}
	918	}
	919
	920	/**
	921	* @desc
	922	* Interworking Application Server test configuration.
	923	* Ummaps/disconnect the related component ports. More information
	924	* can be found in ETSI TS 186 011-2 V2.3.1 Cause 4.3.4.
	925	* @param p_config.gmA Gm A Interface Monitor component
	926	* @param p_config.mw Mw Interface Monitor component
	927	* @param p_config.gmB Gm B Interface Monitor component
	928	* @param p_config.iscA Isc A Interface Monitor component
	929	* @param p_config.iscB Isc B Interface Monitor component
	930	* IscA and IscB Interface Monitor component (optional, can be omitted)
	931	*/
	932	function f_cf_roam_as_down(
	933	inout CF_ROAM_AS p_config
	934	) runs on ImsTestCoordinator {
	935	// Stop traffic capture processing.
	936	timer tc_configureGuard;
	937	var StopTrafficCaptureRsp stopResult;
	938	tc_configureGuard.start(PX_MAX_MSG_WAIT);
	939	acPort.send(m_stopTrafficCaptureReq);
	940	alt {
	941	[] acPort.receive (m_stopTrafficCaptureRsp_any) -> value stopResult {
	942	tc_configureGuard.stop;
	943	if (stopResult.status.code != e_success)
	944	{
	945	log("** TC_IMS_MESS_0001: StopTrafficCaptureReq unsuccessfull! **");
	946	setverdict(fail);
	947	}
	948	}
	949	[] tc_configureGuard.timeout {
	950	log("** TC_IMS_MESS_0001: StopTrafficCaptureReq not answered. **");
	951	setverdict (inconc);
	952	}
	953	}
	954	f_cf_monitor_down(p_config.gmA);
	955	f_cf_monitor_down(p_config.mw);
	956	f_cf_monitor_down(p_config.gmB);
	957	if(isvalue(p_config.iscA)) {
	958	f_cf_monitor_down(p_config.iscA);
	959	}
	960	if(isvalue(p_config.iscB)) {
	961	f_cf_monitor_down(p_config.iscB);
	962	}
	963	}
	964	}
	965
	966	function f_getInterfaceInfoList(
	967	in charstring p_interfaceName,
	968	in integer p_product1,
	969	in integer p_product2
	970	) return InterfaceInfoList {
	971	var InterfaceInfoList v_list := {
	972	f_getInterfaceInfo(p_interfaceName, PX_PRODUCTS[p_product1]),
	973	f_getInterfaceInfo(p_interfaceName, PX_PRODUCTS[p_product2])
	974	};
	975
	976	return v_list;
	977	}
	978
	979	function f_getInterfaceInfo(in charstring p_interfaceName, Product p_product) return InterfaceInfo {
	980	var InterfaceInfo v_info := {
	981	IpInterfaceInfo := {
	982	{
	983	domainName := "invalid",
	984	IpAddress := "0.0.0.0",
	985	portNumbers := {0}
	986	}
	987	}
	988	};
	989
	990	for(var integer i := 0; i < lengthof(p_product.monitorInterfaces); i := i + 1) { // YANN: <= instead of <
	991	if(p_product.monitorInterfaces[i].interfaceName == p_interfaceName) {
	992	return p_product.monitorInterfaces[i].interfaceInfo;
	993	}
	994	}
	995
	996	return v_info;
	997	}
	998
	999
	1000
	1001
	1002	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format