Commit | Line | Data |
---|---|---|
970ed795 | 1 | /****************************************************************************** |
d44e3c4f | 2 | * Copyright (c) 2000-2016 Ericsson Telecom AB |
970ed795 EL |
3 | * All rights reserved. This program and the accompanying materials |
4 | * are made available under the terms of the Eclipse Public License v1.0 | |
5 | * which accompanies this distribution, and is available at | |
6 | * http://www.eclipse.org/legal/epl-v10.html | |
d44e3c4f | 7 | * |
8 | * Contributors: | |
9 | * Balasko, Jeno | |
10 | * Baranyi, Botond | |
11 | * Forstner, Matyas | |
12 | * Raduly, Csaba | |
13 | * Szabados, Kristof | |
14 | * Szabo, Janos Zoltan – initial implementation | |
15 | * Tatarka, Gabor | |
16 | * | |
970ed795 EL |
17 | ******************************************************************************/ |
18 | module ProcPort { | |
19 | ||
20 | type record MyRecord { } | |
21 | ||
22 | signature MyProc(in integer Par1,inout charstring Par2,out float Par3) | |
23 | return boolean | |
24 | exception(integer); | |
25 | signature MyProc2(); | |
26 | type MyProc2 MyProc2Alias; // testing type alias | |
27 | signature MyProc3(in integer I) return float exception(integer); | |
28 | signature MyProc4(in float F) noblock; | |
29 | signature MyProc5(in integer A, in integer B) | |
30 | return float exception(charstring, MyRecord); | |
31 | signature s_StopPTC(); | |
3abe9331 | 32 | signature MyProc6(inout integer I); |
970ed795 EL |
33 | |
34 | template s_StopPTC StopPTC := { } | |
35 | ||
36 | template MyProc5 MyProc5Template_any := { | |
37 | A:=?, | |
38 | B:=? | |
39 | } | |
40 | ||
41 | template MyProc5 MyProc5TemplateP(integer pA,integer pB) := { | |
42 | A:=pA, | |
43 | B:=pB | |
44 | } | |
45 | ||
46 | template MyProc3 MyProc3Template:={ | |
47 | I:=2003 | |
48 | } | |
49 | ||
50 | template MyProc3 MyProc3Template_any:={I:=?} | |
51 | ||
52 | template MyProc3 MyProc3TemplateP (integer P) := { | |
53 | I:=P | |
54 | } | |
55 | ||
56 | template MyProc MyProcTemplateP (integer i,charstring c,float f) := { | |
57 | Par1:=i, | |
58 | Par2:=c, | |
59 | Par3:=f | |
60 | } | |
61 | ||
62 | template MyProc MyProcTemplate:= { | |
63 | Par1:=44, | |
64 | Par2:="Q", | |
65 | Par3:=324.664 | |
66 | } | |
67 | ||
68 | template MyProc MyProcTemplate2:= { | |
69 | Par1:=4200, | |
70 | Par2:="T", | |
71 | Par3:=170.01 | |
72 | } | |
73 | ||
74 | template MyProc MyProcTemplate_any:= { | |
75 | Par1:=?, | |
76 | Par2:=?, | |
77 | Par3:=? | |
78 | } | |
79 | ||
80 | template MyProc2 MyProc2Template := { } | |
81 | ||
82 | type record address { | |
83 | integer a1, | |
84 | integer a2 | |
85 | } | |
86 | ||
87 | template address MyAddress(integer p1,integer p2) := { | |
88 | a1:=p1, | |
89 | a2:=p2 | |
90 | } | |
91 | ||
92 | type port PortAddress procedure { | |
93 | inout MyProc,s_StopPTC; | |
94 | in MyProc2; | |
95 | } with { extension "address" } | |
96 | ||
97 | type port ProcPort1 procedure | |
98 | { | |
99 | inout MyProc,s_StopPTC; | |
100 | in MyProc2; | |
101 | out MyProc3; | |
102 | } with {extension "internal"} | |
103 | ||
104 | type port ProcPort2 procedure | |
105 | { | |
106 | inout MyProc,s_StopPTC; | |
107 | out MyProc2; | |
108 | in MyProc3; | |
109 | } with {extension "internal"} | |
110 | ||
111 | type port ExtProcPort procedure | |
112 | { | |
113 | inout MyProc5; | |
114 | } | |
115 | ||
116 | type port CompileOnlyPort procedure | |
117 | { | |
118 | in MyProc; | |
119 | inout MyProc2; | |
120 | out MyProc3; | |
121 | in MyProc4; | |
122 | inout MyProc5; | |
123 | } | |
124 | ||
125 | type port CompileOnlyPortAddress procedure { | |
126 | out MyProc; | |
127 | in MyProc2; | |
128 | inout MyProc3; | |
129 | out MyProc4; | |
130 | in MyProc5; | |
131 | } with { extension "address" } | |
3abe9331 | 132 | |
133 | type port ProcPort3 procedure { | |
134 | inout MyProc6; | |
135 | } with { extension "internal" } | |
970ed795 EL |
136 | |
137 | type component ProcComponent | |
138 | { | |
139 | port ProcPort1 Port0; | |
140 | } | |
141 | ||
142 | type component ProcComponent2 | |
143 | { | |
144 | port ProcPort2 Port1; | |
145 | } | |
146 | ||
147 | type component ProcComponentMultiPort | |
148 | { | |
149 | port ProcPort1 Port0; | |
150 | port ProcPort2 Port1[4]; | |
151 | port ExtProcPort Port2; | |
152 | port CompileOnlyPort Port3; | |
153 | port PortAddress Port4; | |
154 | } | |
155 | ||
156 | type component eComponent | |
157 | { | |
158 | port ExtProcPort ePort; | |
159 | } | |
160 | ||
161 | type component addressComponent | |
162 | { | |
163 | port PortAddress P; | |
164 | } | |
3abe9331 | 165 | |
166 | type component ProcComponent3 { | |
167 | port ProcPort3 pt; | |
168 | } | |
970ed795 EL |
169 | |
170 | function GetCall_behav1() runs on ProcComponent2 { | |
171 | while(true) { | |
172 | alt { | |
173 | []Port1.getcall(MyProcTemplate_any) { | |
174 | Port1.reply(MyProcTemplate2 value true); | |
175 | } | |
176 | []Port1.getcall(MyProc3Template_any) { | |
177 | Port1.reply(MyProc3Template value 3.1415); | |
178 | } | |
179 | []Port1.getcall(StopPTC) { | |
180 | Port1.reply(StopPTC); | |
181 | stop; | |
182 | } | |
183 | } | |
184 | } | |
185 | } | |
186 | ||
187 | function GetCall_behav2() runs on ProcComponent { | |
188 | while(true) { | |
189 | alt { | |
190 | []Port0.getcall(MyProcTemplate2) { | |
191 | Port0.raise(MyProc,integer:555); | |
192 | } | |
193 | []Port0.getcall(MyProcTemplate_any) { | |
194 | Port0.reply(MyProcTemplate value false); | |
195 | } | |
196 | []Port0.getcall(MyProc2Template) { | |
197 | Port0.reply(MyProc2Template); | |
198 | } | |
199 | []Port0.getcall(StopPTC) { | |
200 | Port0.reply(StopPTC); | |
201 | stop; | |
202 | } | |
203 | } | |
204 | } | |
205 | } | |
206 | ||
207 | function GetCall_behav3() runs on ProcComponent2 { | |
208 | while(true) { | |
209 | alt { | |
210 | []Port1.getcall(MyProcTemplate2) { | |
211 | Port1.raise(MyProc,integer:272869); | |
212 | } | |
213 | []Port1.getcall(MyProcTemplate_any) { | |
214 | Port1.reply(MyProcTemplateP(22,"G",199.99) value false); | |
215 | } | |
216 | []Port1.getcall(MyProc3Template_any) { | |
217 | Port1.reply(MyProc3Template value 2.78); | |
218 | } | |
219 | []Port1.getcall(StopPTC) { | |
220 | Port1.reply(StopPTC); | |
221 | stop; | |
222 | } | |
223 | } | |
224 | } | |
225 | } | |
226 | ||
227 | function Check_getcall_behav() runs on ProcComponent2 { | |
228 | while(true) { | |
229 | alt { | |
230 | []Port1.check(getcall(MyProcTemplate2)) { | |
231 | Port1.getcall; | |
232 | Port1.reply(MyProcTemplate value true); | |
233 | } | |
234 | []Port1.getcall(StopPTC) { | |
235 | Port1.reply(StopPTC); | |
236 | stop; | |
237 | } | |
238 | []Port1.check(getcall) { | |
239 | Port1.getcall; | |
240 | Port1.reply(MyProcTemplate2 value false); | |
241 | } | |
242 | } | |
243 | } | |
244 | } | |
3abe9331 | 245 | |
246 | // parameters values | |
247 | const integer c_CallParam := 10; | |
248 | const integer c_ReplyParam := 19; | |
249 | ||
250 | // error codes | |
251 | template integer t_getCall_invalidValue := -1; | |
252 | template integer t_getCall_timeout := -2; | |
253 | ||
254 | function GetCallParameters_behav() runs on ProcComponent3 { | |
255 | var integer x := 0; | |
256 | timer t := 1.0; | |
257 | t.start; | |
258 | alt { | |
259 | [] pt.getcall(MyProc6:{?}) -> param (x) { | |
260 | if (c_CallParam == x) { pt.reply(MyProc6:{c_ReplyParam}); } | |
261 | else { pt.reply(MyProc6:{t_getCall_invalidValue}); } | |
262 | } | |
263 | [] t.timeout { pt.reply(MyProc6:{t_getCall_timeout}); } | |
264 | } | |
265 | } | |
970ed795 EL |
266 | |
267 | testcase Call_tc1() runs on ProcComponent { | |
268 | /* Non-blocking calls */ | |
269 | var ProcComponent2 PC2; | |
270 | var integer i:=0; | |
271 | var boolean b:=false; | |
272 | var float f:=0.0; | |
273 | timer T:=1.0; | |
274 | PC2:=ProcComponent2.create; | |
275 | PC2.start(GetCall_behav1()); | |
276 | connect(self:Port0,PC2:Port1); | |
277 | T.start; | |
278 | Port0.call(MyProcTemplate,nowait); | |
279 | Port0.call(MyProc3Template,nowait); | |
280 | while(i<2) { | |
281 | alt { | |
282 | []Port0.getreply(MyProcTemplate2) -> value b { | |
283 | if(i==0) { | |
284 | if(b==true) {i:=1;} | |
285 | else {setverdict(fail);stop;} | |
286 | } else { | |
287 | setverdict(inconc);stop; | |
288 | } | |
289 | } | |
290 | []Port0.getreply(MyProc3Template) -> value f { | |
291 | if((i==1)and(f==3.1415)) {i:=2;} | |
292 | else {log(f);setverdict(inconc);stop;} | |
293 | } | |
294 | []T.timeout { | |
295 | setverdict(fail); | |
296 | stop; | |
297 | } | |
298 | } | |
299 | } | |
300 | if(i==2) {setverdict(pass);} | |
301 | Port0.call(StopPTC,0.5) { | |
302 | []Port0.getreply(StopPTC) { } | |
303 | []Port0.catch(timeout) { } | |
304 | } | |
305 | disconnect(self:Port0,PC2:Port1); | |
306 | } | |
307 | ||
308 | testcase Call_tc2() runs on ProcComponent2 { | |
309 | /* Blocking calls */ | |
310 | var ProcComponent PC; | |
311 | var boolean b:=true; | |
312 | PC:=ProcComponent.create; | |
313 | PC.start(GetCall_behav2()); | |
314 | connect(self:Port1,PC:Port0); | |
315 | Port1.call(MyProcTemplate,1.0) { | |
316 | []Port1.getreply(MyProcTemplate value ?) -> value b{ | |
317 | Port1.call(MyProc2Template,0.7) { | |
318 | []Port1.getreply(MyProc2Template) { | |
319 | Port1.call(MyProcTemplate2,0.4) { | |
320 | []Port1.catch(MyProc,integer:555) { | |
321 | if(b==false) {setverdict(pass);} | |
322 | else {setverdict(inconc);} | |
323 | } | |
324 | []Port1.catch(timeout) { | |
325 | setverdict(fail); | |
326 | stop; | |
327 | } | |
328 | } | |
329 | } | |
330 | []Port1.catch(timeout) { | |
331 | setverdict(fail); | |
332 | stop; | |
333 | } | |
334 | } | |
335 | } | |
336 | []Port1.catch(timeout) { | |
337 | setverdict(fail); | |
338 | stop; | |
339 | } | |
340 | } | |
341 | Port1.call(StopPTC,0.5) { | |
342 | []Port1.getreply(StopPTC) { } | |
343 | []Port1.catch(timeout) { } | |
344 | } | |
345 | } | |
346 | ||
347 | testcase extCall_tc1() runs on eComponent system eComponent { | |
348 | map(self:ePort,system:ePort); | |
349 | ePort.call(MyProc5TemplateP(128,32),0.5) { | |
350 | []ePort.getreply(MyProc5Template_any value 4.0) { | |
351 | setverdict(pass); | |
352 | } | |
353 | []ePort.catch(timeout) { | |
354 | setverdict(fail);stop; | |
355 | } | |
356 | } | |
357 | unmap(self:ePort,system:ePort); | |
358 | } | |
359 | ||
360 | testcase extCall_tc2() runs on eComponent system eComponent { | |
361 | map(self:ePort,system:ePort); | |
362 | ePort.call(MyProc5TemplateP(32,128),0.5) { | |
363 | []ePort.getreply(MyProc5Template_any value 0.25) { | |
364 | setverdict(pass); | |
365 | } | |
366 | []ePort.catch(timeout) { | |
367 | setverdict(fail);stop; | |
368 | } | |
369 | } | |
370 | unmap(self:ePort,system:ePort); | |
371 | } | |
372 | ||
373 | testcase extCall_tc3() runs on eComponent system eComponent { | |
374 | map(self:ePort,system:ePort); | |
375 | ePort.call(MyProc5TemplateP(128,0),0.5) { | |
376 | []ePort.catch(MyProc5,charstring:"Divide by 0.") { | |
377 | setverdict(pass); | |
378 | } | |
379 | []ePort.catch(timeout) { | |
380 | setverdict(fail);stop; | |
381 | } | |
382 | } | |
383 | unmap(self:ePort,system:ePort); | |
384 | } | |
385 | ||
386 | testcase Call_MultiPTC_tc() runs on ProcComponent { | |
387 | /* procedure based communication with multiple PTCs */ | |
388 | var ProcComponent2 PC1,PC2; | |
389 | var integer i:=0; | |
390 | timer T:=1.0; | |
391 | PC1:=ProcComponent2.create; | |
392 | PC1.start(GetCall_behav1()); | |
393 | connect(self:Port0,PC1:Port1); | |
394 | PC2:=ProcComponent2.create; | |
395 | PC2.start(GetCall_behav3()); | |
396 | connect(self:Port0,PC2:Port1); | |
397 | T.start; | |
398 | Port0.call(MyProcTemplate,nowait) to PC1; | |
399 | Port0.call(MyProc3Template,nowait) to PC2; | |
400 | while(i<2) { | |
401 | alt { | |
402 | []Port0.getreply(MyProcTemplate2 value true) from PC1 { | |
403 | i:=i+1; | |
404 | } | |
405 | []Port0.getreply(MyProc3Template value 2.78) from PC2 { | |
406 | i:=i+1; | |
407 | } | |
408 | []T.timeout { | |
409 | setverdict(fail);stop; | |
410 | } | |
411 | } | |
412 | } | |
413 | setverdict(pass); | |
414 | Port0.call(StopPTC,0.5) to PC1 { | |
415 | []Port0.getreply(StopPTC) from PC1 { } | |
416 | []Port0.catch(timeout) { setverdict(fail);stop; } | |
417 | } | |
418 | Port0.call(StopPTC,0.5) to PC2 { | |
419 | []Port0.getreply(StopPTC) from PC2 { } | |
420 | []Port0.catch(timeout) { setverdict(fail);stop; } | |
421 | } | |
422 | disconnect(self:Port0,PC1:Port1); | |
423 | disconnect(self:Port0,PC2:Port1); | |
424 | } | |
425 | ||
426 | testcase Call_MultiPTC_anyport_tc() runs on ProcComponentMultiPort { | |
427 | /* testing any-port operations with multiple PTCs */ | |
428 | var ProcComponent2 PC1,PC2; | |
429 | var ProcComponent2 sndr; | |
430 | var integer i:=0; | |
431 | var boolean chk1:=true,chk2:=true; | |
432 | timer T:=1.5; | |
433 | PC1:=ProcComponent2.create; | |
434 | PC1.start(GetCall_behav1()); | |
435 | connect(self:Port0,PC1:Port1); | |
436 | PC2:=ProcComponent2.create; | |
437 | PC2.start(GetCall_behav3()); | |
438 | connect(self:Port0,PC2:Port1); | |
439 | T.start; | |
440 | Port0.call(MyProcTemplate,nowait) to PC1; | |
441 | Port0.call(MyProc3Template,nowait) to PC2; | |
442 | while(i<4) { | |
443 | alt { | |
444 | [chk1]any port.check { | |
445 | i:=i+1; | |
446 | chk1:=false; | |
447 | log("any port.check OK"); | |
448 | } | |
449 | [chk2]any port.check(getreply -> sender sndr) { | |
450 | i:=i+1; | |
451 | chk2:=false; | |
452 | log("any port.check(getreply) OK, sender: ",sndr); | |
453 | } | |
454 | []any port.check(catch) { | |
455 | log("any port.check(catch) matched --> fail"); | |
456 | setverdict(fail);stop; | |
457 | } | |
458 | []any port.getcall { | |
459 | log("any port.getcall matched --> fail"); | |
460 | setverdict(fail);stop; | |
461 | } | |
462 | []any port.getreply from PC1 { | |
463 | log("any port.getreply from PC1 OK"); | |
464 | i:=i+1; | |
465 | } | |
466 | []any port.getreply from PC2 { | |
467 | log("any port.getreply from PC2 OK"); | |
468 | i:=i+1; | |
469 | } | |
470 | []T.timeout { | |
471 | setverdict(fail);stop; | |
472 | } | |
473 | } | |
474 | } | |
475 | setverdict(pass); | |
476 | Port0.call(StopPTC,0.5) to PC1 { | |
477 | []Port0.getreply(StopPTC) from PC1 { } | |
478 | []Port0.catch(timeout) { setverdict(fail);stop; } | |
479 | } | |
480 | Port0.call(StopPTC,0.5) to PC2 { | |
481 | []Port0.getreply(StopPTC) from PC2 { } | |
482 | []Port0.catch(timeout) { setverdict(fail);stop; } | |
483 | } | |
484 | disconnect(self:Port0,PC1:Port1); | |
485 | disconnect(self:Port0,PC2:Port1); | |
486 | } | |
487 | ||
488 | testcase Check_tc1() runs on ProcComponent { | |
489 | var ProcComponent2 PC2; | |
490 | timer T:=1.5; | |
491 | PC2:=ProcComponent2.create; | |
492 | PC2.start(GetCall_behav3()); | |
493 | connect(self:Port0,PC2:Port1); | |
494 | Port0.call(MyProcTemplate2,nowait); | |
495 | T.start; | |
496 | alt { | |
497 | []Port0.check(catch) { } | |
498 | []T.timeout { | |
499 | setverdict(fail); | |
500 | stop; | |
501 | } | |
502 | } | |
503 | alt { | |
504 | []any port.check(catch) { | |
505 | log("any port.check(catch) OK"); | |
506 | } | |
507 | []T.timeout { | |
508 | setverdict(fail); | |
509 | stop; | |
510 | } | |
511 | } | |
512 | alt { | |
513 | []Port0.check(catch(MyProc,integer:272869)) { | |
514 | Port0.catch; | |
515 | } | |
516 | []T.timeout { | |
517 | setverdict(fail); | |
518 | stop; | |
519 | } | |
520 | } | |
521 | Port0.call(MyProcTemplate,nowait); | |
522 | alt { | |
523 | []Port0.check(getreply) { } | |
524 | []T.timeout { | |
525 | setverdict(fail); | |
526 | stop; | |
527 | } | |
528 | } | |
529 | alt { | |
530 | []Port0.check(getreply(MyProcTemplateP(22,"G",199.99) value false)){ | |
531 | Port0.getreply; | |
532 | setverdict(pass); | |
533 | } | |
534 | []T.timeout { | |
535 | setverdict(fail); | |
536 | stop; | |
537 | } | |
538 | } | |
539 | Port0.call(StopPTC,0.5) { | |
540 | []Port0.getreply(StopPTC) { } | |
541 | []Port0.catch(timeout) { } | |
542 | } | |
543 | } | |
544 | ||
545 | testcase Check_tc2() runs on ProcComponent { | |
546 | var ProcComponent2 PC2; | |
547 | PC2:=ProcComponent2.create; | |
548 | PC2.start(Check_getcall_behav()); | |
549 | connect(self:Port0,PC2:Port1); | |
550 | Port0.call(MyProcTemplate2,1.0) { | |
551 | []Port0.getreply(MyProcTemplate value true) { } | |
552 | []Port0.catch(timeout) { | |
553 | setverdict(fail); | |
554 | stop; | |
555 | } | |
556 | } | |
557 | Port0.call(MyProcTemplate,1.0) { | |
558 | []Port0.getreply(MyProcTemplate2 value false) { | |
559 | setverdict(pass); | |
560 | } | |
561 | []Port0.catch(timeout) { | |
562 | setverdict(fail); | |
563 | stop; | |
564 | } | |
565 | } | |
566 | Port0.call(StopPTC,0.5) { | |
567 | []Port0.getreply(StopPTC) { } | |
568 | []Port0.catch(timeout) { } | |
569 | } | |
570 | } | |
571 | ||
572 | testcase PortAddress_internal_usage() runs on ProcComponentMultiPort { | |
573 | /* procedure based internal communication with address-supporting port */ | |
574 | var ProcComponent2 PC2; | |
575 | var integer i:=0; | |
576 | PC2:=ProcComponent2.create; | |
577 | PC2.start(GetCall_behav3()); | |
578 | connect(self:Port4,PC2:Port1); | |
579 | Port4.call(MyProcTemplateP(11,"T",99.012),1.0) { | |
580 | []Port4.getreply(MyProcTemplateP(22,"G",199.99) value false) { | |
581 | i:=i+1; | |
582 | } | |
583 | []Port4.catch(timeout) { | |
584 | setverdict(fail);stop; | |
585 | } | |
586 | } | |
587 | Port4.call(MyProcTemplate2,1.0) { | |
588 | []Port4.catch(MyProc,integer:272869) { | |
589 | i:=i+1; | |
590 | } | |
591 | []Port4.catch(timeout) { | |
592 | setverdict(fail);stop; | |
593 | } | |
594 | } | |
595 | if(i==2){setverdict(pass);} | |
596 | Port4.call(StopPTC,1.0) { | |
597 | []Port4.getreply(StopPTC) { } | |
598 | []Port4.catch(timeout) { | |
599 | setverdict(fail); | |
600 | } | |
601 | } | |
602 | } | |
603 | ||
604 | testcase PortAddress_external_usage1() runs on addressComponent | |
605 | system addressComponent { | |
606 | map(self:P,system:P); | |
607 | P.call(MyProcTemplate,1.0) to valueof(MyAddress(321,67)) { | |
608 | []P.getreply(MyProcTemplate_any value true) from MyAddress(67,321) { | |
609 | setverdict(pass); | |
610 | } | |
611 | []P.catch(timeout) { | |
612 | setverdict(fail); | |
613 | } | |
614 | } | |
615 | unmap(self:P,system:P); | |
616 | } | |
617 | ||
618 | testcase PortAddress_external_usage2() runs on addressComponent | |
619 | system addressComponent { | |
620 | map(self:P,system:P); | |
621 | P.call(MyProcTemplate,1.0) to valueof(MyAddress(321,68)) { | |
622 | []P.catch(MyProc,integer:389) from MyAddress(68,321) { | |
623 | setverdict(pass); | |
624 | } | |
625 | []P.catch(timeout) { | |
626 | setverdict(fail); | |
627 | } | |
628 | } | |
629 | unmap(self:P,system:P); | |
630 | } | |
631 | ||
632 | function signatureEncode(template MyProc par1, template MyProc par2) runs on addressComponent | |
633 | { | |
634 | log(par1, par2); | |
635 | } | |
636 | ||
3abe9331 | 637 | // tests the 'param' directive in functions 'getcall' and 'getreply', |
638 | // specificly with signatures containing 'inout' parameters (HT93096) | |
639 | testcase GetReplyParameters_tc() runs on ProcComponent3 { | |
640 | var ProcComponent3 c := ProcComponent3.create; | |
641 | connect(c:pt, self:pt); | |
642 | c.start(GetCallParameters_behav()); | |
643 | ||
644 | var integer x := 0; | |
645 | pt.call(MyProc6:{c_CallParam}, 1.0) { | |
646 | [] pt.getreply(MyProc6:{t_getCall_invalidValue}) { setverdict(fail, "invalid getcall parameter"); } | |
647 | [] pt.getreply(MyProc6:{t_getCall_timeout}) { setverdict(fail, "getcall timed out"); } | |
648 | [] pt.getreply(MyProc6:{?}) -> param (x) { | |
649 | if (c_ReplyParam == x) { setverdict(pass); } | |
650 | else { setverdict(fail, "invalid getreply parameter"); } | |
651 | } | |
652 | [] pt.catch(timeout) { setverdict(fail, "getreply timed out"); } | |
653 | } | |
654 | ||
655 | c.done; | |
656 | } | |
657 | ||
970ed795 EL |
658 | control { |
659 | execute(Call_tc1()); | |
660 | execute(Call_tc2()); | |
661 | execute(extCall_tc1()); | |
662 | execute(extCall_tc2()); | |
663 | execute(extCall_tc3()); | |
664 | execute(Call_MultiPTC_tc()); | |
665 | execute(Call_MultiPTC_anyport_tc()); | |
666 | execute(Check_tc1()); | |
667 | execute(Check_tc2()); | |
668 | execute(PortAddress_internal_usage()); | |
669 | execute(PortAddress_external_usage1()); | |
670 | execute(PortAddress_external_usage2()); | |
3abe9331 | 671 | execute(GetReplyParameters_tc()); |
970ed795 EL |
672 | } |
673 | } |