Context Navigation

AtsImsIot_TestConfiguration.ttcn

Last change on this file was 22, checked in by rings, 14 years ago

Property svn:executable set to ``*
File size: 29.7 KB

Line
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