1 .******************************************************************************
2 .* Copyright (c) 2000-2014 Ericsson Telecom AB
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
7 .******************************************************************************/
11 .* EDML webpage: http://cpi.ericsson.se/dwaxe/
12 .* EDML2PDF converter: http://dwaxe.ericsson.se/x2pdf
13 .* EDML user guide: http://www.lmc.ericsson.se/~lmcmarg/isit/edml_ug.html
15 .* Document header information
16 :docname.Test Description
17 :docno.xx/152 91-CRL 113 200/5 Uen
21 :prep.ETH/XZ Jeno Balasko
22 :appr.ETH/XZ (Gyula Koos)
25 :title.Test description of the TTCN-3 Semantic Analyzer: Other requirements
27 .*---------------------------------------------------------------------*
29 .*---------------------------------------------------------------------*
30 .*---------------------------------------------------------------------*
32 .*---------------------------------------------------------------------*
34 REV DATE PREPARED CHANGE
35 __________________________________________________
36 PA1 2005-02-19 ETHGASZ New document for TITAN R6
37 A 2005-03-18 ETHGASZ Approved after review
38 B 2005-08-16 ETIBHRA New req. added (SA-9/18,19,20)
39 C 2007-03-06 EJNOSZA Updates for TITAN R7A (expected error messages for identifier overloading)
40 D 2007-06-08 EJNOSZA Updates for TITAN R7B (expected error messages for identifier overloading)
41 E 2008-10-01 EKRISZA Updates for TITAN R7E
42 F 2010-01-18 EKRISZA Updated for TITAN R8C
43 K 2011-10-10 EKRISZA Updated for TITAN R8H
44 A 2011-12-12 EKRISZA Updated for release
45 A 2012-06-27 EFERKOV Updated for release
46 A 2013-01-17 EKRIPND Updated for release
47 A 2015-04-27 ETHBAAT Updated for release
50 .*---------------------------------------------------------------------*
52 .*---------------------------------------------------------------------*
53 The purpose of this Test Description is to define and describe the function
54 test activity for the Semantic Analyser functionality of the TTCN-3 compiler:
55 :nl.SA-9/x: Other requirements.
56 :p.The specification of the test cases can be found in this document.
57 .*---------------------------------------------------------------------*
59 .*---------------------------------------------------------------------*
60 .*---------------------------------------------------------------------*
62 .*---------------------------------------------------------------------*
63 No specific hardware requirement.
64 .*---------------------------------------------------------------------*
66 .*---------------------------------------------------------------------*
67 Tests shall be carried out on the following platforms:
69 :li D='1.'.Solaris 8 (Sun OS 5.8) (gcc 3.0.4)
70 :li D='2.'.SUSE Linux Enterprise server 8 (2.4.19-4GB) (gcc 3.2)
71 :li D='3.'.CYGWIN_NT-5.0 (Cygwin DLL: 1.5.12) on Windows 2000 (gcc 3.3.3)
73 .*---------------------------------------------------------------------*
75 .*---------------------------------------------------------------------*
76 The test environment had been setup in CVS. The tester program is stored in:
77 :nl.TTCNv3/function_test/Tools/SAtester.pl
78 :nl.Test cases are stored with extension .script in the directory:
79 :nl.TTCNv3/function_test/Semantic_Analyser/
80 .*---------------------------------------------------------------------*
82 .*---------------------------------------------------------------------*
83 Install proper TITAN binaries on the used platforms and make sure that
84 your environment settings are correct:
86 :li D='1.'.TTCN3_DIR is set
87 :li D='2.'.$TTCN3_DIR/bin is added to the PATH variable
88 :li D='3.'.$TTCN3_DIR/lib is added to the LD_LIBRARY_PATH variable
89 :li D='4.'.Perl 5.6.0 or higher is available on the platform
90 :li D='5.'.Create a symlink to your Perl binary into the directory where the
91 test cases are stored:
92 :nl.ln -s <your Perl> perl
94 .*---------------------------------------------------------------------*
96 .*---------------------------------------------------------------------*
97 A tester program had been written in Perl especially for the Semantic Analyser
98 tests. For the list of command line parameters, type 'SAtester.pl -help', for the
99 complete documentation, type 'SAtester.pl -doc'.
100 :p.Test cases are specified in the Test Description documents in EDML format.
101 The tester program parses these files and generates the TTCN-3/ASN.1 modules, then
102 calls the compiler to compile them. The result printout is then matched against
103 different patterns to be able to set the verdict. Test cases contain not only
104 the source modules, but the patterns as well.
105 :p.The tester program allows one-by-one execution of test cases and batched
107 :p.NOTE: the tester program requires Perl 5.6.0 or higher.
108 .*---------------------------------------------------------------------*
110 .*---------------------------------------------------------------------*
111 .*---------------------------------------------------------------------*
112 :h3.Module Parameters->Redeclaration of a module parameter SA-9/1
113 .*---------------------------------------------------------------------*
114 Requirement: Redeclaration of a module parameter.
116 :nl.Redefinition of the module parameter is not allowed.
118 .*---------------------------------------------------------------------*
119 :h4.Module Parameters->Redeclaration of a module parameter with a different type
120 .*---------------------------------------------------------------------*
122 <TC - Module Parameters->Redeclaration of a module parameter with a different type>
126 <MODULE TTCN ModuleA ModuleA.ttcn>
130 integer MyTSP2 := 10;
131 boolean MyTSP1 := false;
136 <RESULT IF_PASS COUNT 2>
137 (?im)\berror\b.+?duplicate.+?definition.+?MyTSP
139 <RESULT IF_PASS COUNT 2>
140 (?im)\bnote\b.+?previous.+?definition
142 <RESULT IF_PASS COUNT 2>
145 <RESULT IF_PASS POSITIVE>
146 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
150 .*---------------------------------------------------------------------*
151 :h4.Module Parameters->Redeclaration of a module parameter in a different group
152 .*---------------------------------------------------------------------*
155 <TC - Module Parameters->Redeclaration of a module parameter in a different group>
159 <MODULE TTCN ModuleA ModuleA.ttcn>
163 integer MyTSP2 := 10;
166 boolean MyTSP1 := false;
171 <RESULT IF_PASS COUNT 2>
172 (?im)\berror\b.+?duplicate.+?definition.+?MyTSP
174 <RESULT IF_PASS COUNT 2>
175 (?im)\bnote\b.+?previous.+?definition
177 <RESULT IF_PASS COUNT 2>
180 <RESULT IF_PASS POSITIVE>
181 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
186 .*---------------------------------------------------------------------*
187 :h3.Signatures->Duplicate exception type in a signature SA-9/2
188 .*---------------------------------------------------------------------*
189 Requirement: Duplicate exception type in a signature.
191 :nl.One or more exception type is listed in a signature more than once.
192 .*---------------------------------------------------------------------*
193 :h4.Signatures->Duplicate exception type in a signature
194 .*---------------------------------------------------------------------*
197 <TC - Signatures->Duplicate exception type in a signature>
201 <MODULE TTCN ModuleA ModuleA.ttcn>
203 signature s() noblock
205 bitstring, boolean, charstring, universal charstring,
206 integer, octetstring, objid, hexstring, verdicttype, float,
207 bitstring, boolean, charstring, universal charstring,
208 integer, octetstring, objid, hexstring, verdicttype, float);
211 <RESULT IF_PASS COUNT 10>
212 (?im)\berror\b.+?duplicate.+?type
214 <RESULT IF_PASS COUNT 10>
215 (?im)\bnote\b.+?already.+?here
217 <RESULT IF_PASS COUNT 10>
220 <RESULT IF_PASS POSITIVE>
221 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
227 .*---------------------------------------------------------------------*
228 :h3.Signatures-> 'all' shall not be mixed with additional names SA-9/2
229 .*---------------------------------------------------------------------*
230 Requirement: 'all' shall not be mixed with additional names in one list.
232 :nl.Becasue the 'all' is not supported currently, it can not be tested.
233 .*---------------------------------------------------------------------*
234 :h3.Import-> Duplicated module reference in import statements SA-9/3
235 .*---------------------------------------------------------------------*
236 Requirement: Duplicated module reference in import statements.
238 :nl.A module name is listed more than once to import from.
239 .*---------------------------------------------------------------------*
240 :h4.Import->Duplicated module reference in import statements
241 .*---------------------------------------------------------------------*
244 <TC - Import->Duplicated module reference in import statements>
248 <MODULE TTCN ModuleA ModuleA.ttcn>
250 import from ModuleB all;
251 import from ModuleB all;
254 <MODULE TTCN ModuleB ModuleB.ttcn>
259 <RESULT IF_PASS NEGATIVE>
262 <RESULT IF_PASS POSITIVE>
263 (?im)Notify: File `ModuleA.hh' was generated.
268 .*---------------------------------------------------------------------*
269 :h3.No signatures in the test suite when using 'all' in port definition SA-9/4
270 .*---------------------------------------------------------------------*
271 Requirement: No signatures in the test suite when using 'all' in port
273 :nl.Explanation:Using the all keyword in one of the lists associated to a
274 :nl.port type allows all of signatures defined in the module to be
275 :nl.received and sent over port. SA shall detect the cases when no
276 :nl.signatures are defined in the test suite, but receive-like port
277 :nl.operations (e.g. getcall, getreply, catch) are used.
278 :nl.NOTE:Because the 'all' is not supported currently, it can not be tested.
280 .*---------------------------------------------------------------------*
281 :h4.No signatures in the test suite when using 'all' in port definition
282 .*---------------------------------------------------------------------*
284 <TC - No signatures in the test suite when using 'all' in port definition>
288 <MODULE TTCN ModuleA ModuleA.ttcn>
290 type port MyPortType1 procedure { inout all}
291 type component MyComp {
292 port MyPortType1 MyPort1;
296 <RESULT IF_FAIL COUNT 1>
299 <RESULT IF_FAIL POSITIVE>
300 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
305 .*---------------------------------------------------------------------*
306 :h3.Communication operations->Port operation when no ports defined 9/5
307 .*---------------------------------------------------------------------*
308 Requirement: Port operation when no ports defined.
310 :nl.Port operations on a component that has no ports defined shall be
312 .*---------------------------------------------------------------------*
313 :h4.Communication operations->Port operation when no ports defined
314 .*---------------------------------------------------------------------*
316 <TC - Communication operations->Port operation when no ports defined>
320 <MODULE TTCN ModuleA ModuleA.ttcn>
322 signature MySig() noblock;
323 type component MyComp {
327 // TR 699: Port and timer operation when no ports or timer defined
328 altstep MyAltstep() runs on MyComp {
329 [] any port.receive { setverdict(fail); }
330 [] any port.trigger { setverdict(fail); }
331 [] any port.getcall { setverdict(fail); }
332 [] any port.getreply { setverdict(fail); }
333 [] any port.catch { setverdict(fail); }
334 [] any port.check(-> sender MyWar1) { setverdict(fail); }
335 [] any port.check(receive) { setverdict(fail); }
336 [] any port.check(getcall) { setverdict(fail); }
337 [] any port.check(getreply) { setverdict(fail); }
338 [] any port.check(catch) { setverdict(fail); }
348 <RESULT IF_FAIL COUNT 1>
351 <RESULT IF_FAIL POSITIVE>
352 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
357 .*---------------------------------------------------------------------*
358 :h3.Timer operations when no timers defined SA-9/6
359 .*---------------------------------------------------------------------*
360 Requirement: Timer operations when no timers defined.
362 :nl.Timer operations shall be handled correctly if no timers are defined.
363 .*---------------------------------------------------------------------*
364 :h4.Timer operations when no timers defined
365 .*---------------------------------------------------------------------*
368 <TC - Timer operations when no timers defined>
372 <MODULE TTCN ModuleA ModuleA.ttcn>
374 type component MyComp {}
375 function MyFunc1() runs on MyComp {
378 // TR 699: Port and timer operation when no ports or timer defined
379 // would block forever
381 if (any timer.running) { setverdict(fail); }
382 else { setverdict(pass); }
384 testcase MyTC() runs on MyComp {
389 <RESULT IF_FAIL COUNT 3>
392 <RESULT IF_FAIL POSITIVE>
393 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
399 .*---------------------------------------------------------------------*
400 :h3.Import-> Import from the same module SA-9/7
401 .*---------------------------------------------------------------------*
402 Requirement: Import from the same module.
404 :nl.A module cannot import from itself.
405 .*---------------------------------------------------------------------*
406 :h4.Import->Import from the same module
407 .*---------------------------------------------------------------------*
410 <TC - Import->Import from the same module>
414 <MODULE TTCN ModuleA ModuleA.ttcn>
416 import from ModuleA all;
419 <RESULT IF_PASS COUNT 1>
420 (?im)\berror\b.+?\bimport\b.+?\bitself\b
423 <RESULT IF_PASS COUNT 1>
426 <RESULT IF_PASS POSITIVE>
427 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
433 .*---------------------------------------------------------------------*
434 :h3.Functions->Return value SA-9/8
435 .*---------------------------------------------------------------------*
436 Requirement: Functions->Return value.
438 :nl.The keyword return, when used in the body of the function with a
439 :nl.return type defined in its header, always shall be followed by a value,
440 :nl.a constant or variable reference or an expression presenting the return
442 .*---------------------------------------------------------------------*
443 :h4.Functions->Return value if no return type defined
444 .*---------------------------------------------------------------------*
446 <TC - Functions->Return value if no return type defined>
450 <MODULE TTCN ModuleA ModuleA.ttcn>
452 // no return value, but try to return an actual value
453 // catched by the parser curently
454 function MyFunc1() { if(true) {return '11A7'O;}}
457 <RESULT IF_PASS COUNT 1>
458 (?im)\berror\b.+?function.+?not.+?have.+?return.+?type
460 <RESULT IF_PASS COUNT 1>
463 <RESULT IF_PASS POSITIVE>
464 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
468 .*---------------------------------------------------------------------*
469 :h4.Functions->Missing return value, but return type defined
470 .*---------------------------------------------------------------------*
472 <TC - Functions->Missing return value, but return type defined>
476 <MODULE TTCN ModuleA ModuleA.ttcn>
478 // missing return value
479 // catched by the parser
480 function MyFunc1() return float {if(true) {return;}}
483 <RESULT IF_PASS COUNT 1>
484 (?im)\berror\b.+?missing.+?return.+?value
486 <RESULT IF_PASS COUNT 1>
487 (?is)\berror.+?control.+?might.+?leave.+?without.+?reaching.+?return.+?statement
489 <RESULT IF_PASS POSITIVE>
490 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
494 .*---------------------------------------------------------------------*
495 :h4.Functions->Missing return value, but return type defined indirect case 1
496 .*---------------------------------------------------------------------*
499 <TC - Functions->Missing return value, but return type defined indirect case 1>
503 <MODULE TTCN ModuleA ModuleA.ttcn>
505 function MyFunc1() {return;}
506 function MyFunc2(integer par) return integer {return (par + 10);}
507 function MyFunc3() return float {
508 if(true) {return MyFunc1();}
512 <RESULT IF_PASS COUNT 1>
513 (?is)\berror.+?control.+?might.+?leave.+?without.+?reaching.+?return.+?statement
515 <RESULT IF_PASS COUNT 1>
516 (?is)\bexpected\b.+?\bfunction\b
518 <RESULT IF_PASS POSITIVE>
519 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
523 .*---------------------------------------------------------------------*
524 :h4.Functions->Missing return value, but return type defined indirect case 2
525 .*---------------------------------------------------------------------*
528 <TC - Functions->Missing return value, but return type defined indirect case 2>
532 <MODULE TTCN ModuleA ModuleA.ttcn>
534 function MyFunc1() {return;}
535 function MyFunc2(integer par) return integer {return (par + 10);}
536 function MyFunc4() return float {
537 if(true) {return int2float( MyFunc2(MyFunc1() ));}
541 <RESULT IF_PASS COUNT 1>
542 (?is)\berror.+?control.+?might.+?leave.+?without.+?reaching.+?return.+?statement
544 <RESULT IF_PASS COUNT 1>
545 (?is)\bexpected\b.+?\bfunction\b
547 <RESULT IF_PASS POSITIVE>
548 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
553 .*---------------------------------------------------------------------*
554 :h4.Functions->Missing return value, but return type defined indirect case 3
555 .*---------------------------------------------------------------------*
557 <TC - Functions->Missing return value, but return type defined indirect case 3>
561 <MODULE TTCN ModuleA ModuleA.ttcn>
563 function MyFunc1() {return;}
565 // void return value is not allowed in expression
566 var integer MyVar := 666 + MyFunc1() - 666;
570 <RESULT IF_PASS COUNT 1>
573 <RESULT IF_PASS COUNT 1>
574 (?is)\bexpected\b.+?\bfunction\b
576 <RESULT IF_PASS POSITIVE>
577 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
582 .*---------------------------------------------------------------------*
583 :h3.Functions->runs on clause SA-9/9
584 .*---------------------------------------------------------------------*
585 Requirement: Functions->runs on clause.
587 :nl.A function without runs on clause shall never invoke a function or
588 :nl.altstep or activate an altstep as default with a runs on clause locally.
589 :nl.Functions started by using the start test component operation shall
590 :nl.always have a runs on clause.
591 :nl.Functions used in the control part of a TTCN-3 module shall have no
593 .*---------------------------------------------------------------------*
594 :h4.Functions->runs on clause, referencing to a functions with runs on
595 .*---------------------------------------------------------------------*
598 <TC - Functions->runs on clause, referencing to a functions with runs on>
602 <MODULE TTCN ModuleA ModuleA.ttcn>
604 type port MyPortType message { inout integer }
605 type component MyComp { port MyPortType MyPort }
606 function MyFunc_comp() runs on MyComp {return;}
607 function NastyFunc01() {
608 if (true) { MyFunc_comp(); }
612 <RESULT IF_PASS COUNT 1>
615 <RESULT IF_PASS COUNT 1>
616 (?is)\bcannot\b.+?\bcall\b
618 <RESULT IF_PASS POSITIVE>
619 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
624 .*---------------------------------------------------------------------*
625 :h4.Functions->runs on clause, referencing to an altstep with runs on
626 .*---------------------------------------------------------------------*
628 <TC - Functions->runs on clause, referencing to an altstep with runs on>
632 <MODULE TTCN ModuleA ModuleA.ttcn>
634 type port MyPortType message { inout integer }
635 type component MyComp { port MyPortType MyPort }
636 altstep MyAltstep_comp() runs on MyComp { [] MyPort.trigger {} }
637 function NastyFunc02(inout MyPortType loc_port) {
640 [] loc_port.trigger {}
647 <RESULT IF_PASS COUNT 1>
650 <RESULT IF_PASS COUNT 1>
651 (?is)\bcannot\b.+?\bcall\b
653 <RESULT IF_PASS POSITIVE>
654 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
658 .*---------------------------------------------------------------------*
659 :h4.Functions->runs on clause, referencing to a func with runs on,indirect call
660 .*---------------------------------------------------------------------*
663 <TC - Functions->runs on clause, referencing to a func with runs on,indirect call>
667 <MODULE TTCN ModuleA ModuleA.ttcn>
669 type port MyPortType message { inout integer }
670 type component MyComp { port MyPortType MyPort }
671 function MyFunc_comp2() runs on MyComp return integer {return 0;}
672 function MyCoolFunction1 (integer par) return integer {return par;}
673 function NastyFunc03() return float {
674 if (true) { return int2float( MyCoolFunction1(MyFunc_comp2()) ); }
678 <RESULT IF_PASS COUNT 1>
679 (?is)\berror.+?control.+?might.+?leave.+?without.+?reaching.+?return.+?statement
681 <RESULT IF_PASS COUNT 1>
682 (?is)\bcannot\b.+?\bcall\b
684 <RESULT IF_PASS POSITIVE>
685 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
689 .*---------------------------------------------------------------------*
690 :h4.Functions->runs on clause, default activation/deactivation
691 .*---------------------------------------------------------------------*
694 <TC - Functions->runs on clause, default activation/deactivation>
698 <MODULE TTCN ModuleA ModuleA.ttcn>
700 type port MyPortType message { inout integer }
701 type component MyComp { port MyPortType MyPort }
702 altstep MyAltstep_comp() runs on MyComp { [] MyPort.trigger {} }
703 function NastyFunc04() {
704 var default MyDef := activate(MyAltstep_comp());
709 <RESULT IF_PASS COUNT 1>
712 <RESULT IF_PASS COUNT 1>
713 (?is)\bcannot\b.+?\bactivate\b
715 <RESULT IF_PASS POSITIVE>
716 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
720 .*---------------------------------------------------------------------*
721 :h4.Functions->runs on clause, start operations
722 .*---------------------------------------------------------------------*
725 <TC - Functions->runs on clause, start operations>
729 <MODULE TTCN ModuleA ModuleA.ttcn>
731 type port MyPortType message { inout integer }
732 type component MyComp { port MyPortType MyPort }
733 function MyFunc_comp3(integer par) runs on MyComp {}
734 function MyFunc_nocomp() {}
735 function MyFunc_nocomp2(integer par) return integer { return 0; }
737 var MyComp MyComponent := MyComp.create;
738 var MyComp MyComponent2 := MyComp.create;
739 MyComponent.start(MyFunc_nocomp());
740 // this should be ok however
741 MyComponent2.start(MyFunc_comp3(MyFunc_nocomp2(666)));
745 <RESULT IF_PASS COUNT 1>
748 <RESULT IF_PASS COUNT 1>
749 (?is)\bcannot\b.+?\bstarted\b
751 <RESULT IF_PASS POSITIVE>
752 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
757 .*---------------------------------------------------------------------*
758 :h4.Functions->runs on clause, function called from a template
759 .*---------------------------------------------------------------------*
761 <TC - Functions->runs on clause, function called from a template>
765 <MODULE TTCN ModuleA ModuleA.ttcn>
767 type port MyPortType message { inout integer }
768 type component MyComp { port MyPortType MyPort }
769 function MyFunc_comp2() runs on MyComp return integer {return 0;}
770 template integer MyTemplate := MyFunc_comp2();
773 <RESULT IF_PASS COUNT 1>
776 <RESULT IF_PASS COUNT 1>
777 (?is)\bcannot\b.+?\bcall\b
779 <RESULT IF_PASS POSITIVE>
780 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
784 .*---------------------------------------------------------------------*
785 :h4.Functions->runs on clause, functions in the control part
786 .*---------------------------------------------------------------------*
789 <TC - Functions->runs on clause, functions in the control part>
793 <MODULE TTCN ModuleA ModuleA.ttcn>
795 type port MyPortType message { inout integer }
796 type component MyComp { port MyPortType MyPort }
797 function MyFunc_comp() runs on MyComp {return;}
798 function MyFunc_comp2() runs on MyComp return integer {return 0;}
799 function MyCoolFunction1 (integer par) return integer {return par;}
804 MyVar := MyCoolFunction1(MyFunc_comp2());
809 <RESULT IF_PASS COUNT 2>
812 <RESULT IF_PASS COUNT 2>
813 (?is)\bcannot\b.+?\bcall\b
815 <RESULT IF_PASS POSITIVE>
816 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
821 .*---------------------------------------------------------------------*
822 :h3.Altsteps->runs on clause SA-9/9
823 .*---------------------------------------------------------------------*
824 Requirement: Altsteps->runs on clause (16.1.0).
826 :nl.An altstep without runs on clause shall never invoke a function or
827 :nl.altstep or activate an altstep as default with a runs on clause locally.
828 .*---------------------------------------------------------------------*
829 :h4.Altsteps->runs on clause, referencing to an altstep() with runs on
830 .*---------------------------------------------------------------------*
833 <TC - Altsteps->runs on clause, referencing to an altstep() with runs on>
837 <MODULE TTCN ModuleA ModuleA.ttcn>
839 type port MyPortType message { inout integer }
840 type component MyComp { port MyPortType MyPort }
841 altstep MyAltstep_comp() runs on MyComp { [] MyPort.trigger {} }
843 altstep NastyAltstep01(inout MyPortType loc_port) {
844 [] loc_port.trigger {}
849 <RESULT IF_PASS COUNT 1>
852 <RESULT IF_PASS COUNT 1>
853 (?is)\bcannot\b.+?\bcall\b
855 <RESULT IF_PASS POSITIVE>
856 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
860 .*---------------------------------------------------------------------*
861 :h4.Altsteps->runs on clause, referencing to a function() with runs on
862 .*---------------------------------------------------------------------*
865 <TC - Altsteps->runs on clause, referencing to a function() with runs on>
869 <MODULE TTCN ModuleA ModuleA.ttcn>
871 type port MyPortType message { inout integer }
872 type component MyComp { port MyPortType MyPort }
873 function MyFunc_comp() runs on MyComp {}
875 altstep NastyAltstep02(inout MyPortType loc_port) {
876 [] loc_port.trigger { MyFunc_comp(); }
880 <RESULT IF_PASS COUNT 1>
883 <RESULT IF_PASS COUNT 1>
884 (?is)\bcannot\b.+?\bcall\b
886 <RESULT IF_PASS POSITIVE>
887 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
891 .*---------------------------------------------------------------------*
892 :h4.Altsteps->runs on clause, default activation/deactivation
893 .*---------------------------------------------------------------------*
896 <TC - Altsteps->runs on clause, default activation/deactivation>
900 <MODULE TTCN ModuleA ModuleA.ttcn>
902 type port MyPortType message { inout integer }
903 type component MyComp { port MyPortType MyPort }
904 altstep MyAltstep_comp() runs on MyComp { [] MyPort.trigger {} }
906 altstep NastyAltstep03(inout MyPortType loc_port) {
907 var default MyDef := activate(MyAltstep_comp());
908 [] loc_port.trigger { deactivate(MyDef); }
912 <RESULT IF_PASS COUNT 1>
915 <RESULT IF_PASS COUNT 1>
916 (?is)\bcannot\b.+?\bactivate\b
918 <RESULT IF_PASS POSITIVE>
919 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
925 .*---------------------------------------------------------------------*
926 :h3.Goto statement SA-9/10
927 .*---------------------------------------------------------------------*
928 Requirement: Goto statement.
930 :nl. - It is not allowed to jump out of or into functions, test cases,
931 :nl. altsteps and the control part of a TTCN-3 module
932 :nl. - It is not allowed to jump into a sequence of statements defined in
933 :nl. a compound statement (i.e. alt statement, while loop, for loop,
934 :nl. if-else statement, do- while loop and the interleave statement)
935 :nl. - It is not allowed to use the goto statement within an interleave
936 :nl. statement (see the SA-9/20)
937 :nl. NOTE: the first is covered by scopes implicitly
938 .*---------------------------------------------------------------------*
939 :h4.Goto statement, jump into alt statement
940 .*---------------------------------------------------------------------*
943 <TC - Goto statement, jump into alt statement>
947 <MODULE TTCN ModuleA ModuleA.ttcn>
956 [b<1.0] Timy.timeout {
958 locpar := locpar + 1; }
964 <RESULT IF_PASS COUNT 1>
967 <RESULT IF_PASS COUNT 1>
968 (?is)\bnot\b.+?\bdefined\b
970 <RESULT IF_PASS POSITIVE>
971 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
975 .*---------------------------------------------------------------------*
976 :h4.Goto statement, jump into if-else statement
977 .*---------------------------------------------------------------------*
980 <TC - Goto statement, jump into if-else statement>
984 <MODULE TTCN ModuleA ModuleA.ttcn>
989 if (true) { label Label04; locpar := 666; }
990 else { label Label05; locpar := -666; }
996 <RESULT IF_PASS COUNT 2>
999 <RESULT IF_PASS COUNT 2>
1000 (?is)\blabel\b.+?\bused\b.+?\bnot\b.+?\bdefined\b
1002 <RESULT IF_PASS POSITIVE>
1003 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1007 .*---------------------------------------------------------------------*
1008 :h4.Goto statement, jump into while statement
1009 .*---------------------------------------------------------------------*
1012 <TC - Goto statement, jump into while statement>
1016 <MODULE TTCN ModuleA ModuleA.ttcn>
1029 <RESULT IF_PASS COUNT 1>
1032 <RESULT IF_PASS COUNT 1>
1033 (?is)\bnot\b.+?\bdefined\b
1035 <RESULT IF_PASS POSITIVE>
1036 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1040 .*---------------------------------------------------------------------*
1041 :h4.Goto statement, jump into do-while statement
1042 .*---------------------------------------------------------------------*
1045 <TC - Goto statement, jump into do-while statement>
1049 <MODULE TTCN ModuleA ModuleA.ttcn>
1062 <RESULT IF_PASS COUNT 1>
1065 <RESULT IF_PASS COUNT 1>
1066 (?is)\bnot\b.+?\bdefined\b
1068 <RESULT IF_PASS POSITIVE>
1069 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1073 .*---------------------------------------------------------------------*
1074 :h4.Goto statement, jump into for statement
1075 .*---------------------------------------------------------------------*
1078 <TC - Goto statement, jump into for statement>
1082 <MODULE TTCN ModuleA ModuleA.ttcn>
1087 for(var integer j:=1; j<10; j:=j+1) {
1095 <RESULT IF_PASS COUNT 1>
1098 <RESULT IF_PASS COUNT 1>
1099 (?is)\bnot\b.+?\bdefined\b
1101 <RESULT IF_PASS POSITIVE>
1102 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1107 .*---------------------------------------------------------------------*
1108 :h4.Goto statement, jump over the variable definition case 1
1109 .*---------------------------------------------------------------------*
1112 <TC - Goto statement, jump over the variable definition case 1>
1116 <MODULE TTCN ModuleA ModuleA.ttcn>
1128 <RESULT IF_PASS COUNT 1>
1129 (?im)\berror\b.+?\bJump\b.+?\bcrosses\b
1132 <RESULT IF_PASS COUNT 1>
1135 <RESULT IF_PASS POSITIVE>
1136 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1142 .*---------------------------------------------------------------------*
1143 :h4.Goto statement, jump over the variable definition case 2
1144 .*---------------------------------------------------------------------*
1147 <TC - Goto statement, jump over the variable definition case 2>
1151 <MODULE TTCN ModuleA ModuleA.ttcn>
1153 function myFunc(integer par)
1155 for (var integer i := 0; i < 10; i := i + 1) {
1169 <RESULT IF_PASS COUNT 1>
1170 (?im)\berror\b.+?\bJump\b.+?\bcrosses\b
1173 <RESULT IF_PASS COUNT 1>
1176 <RESULT IF_PASS POSITIVE>
1177 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1182 .*---------------------------------------------------------------------*
1183 :h3.Stop operation SA-9/11
1184 .*---------------------------------------------------------------------*
1185 Requirement: Stop operation.
1187 :nl.The stop statement terminates execution in different ways depending
1188 :nl.on the context in which it is used. When used in the control part of
1189 :nl.a module or in a function used by the control part of a module, it
1190 :nl.terminates the execution of the module control part.
1191 :nl.NOTE: therefore, self.stop shall be detected in the control part or
1192 :nl.function/altstep without runs on clause.
1193 .*---------------------------------------------------------------------*
1194 :h4.Stop operation in altstep without runs on clause
1195 .*---------------------------------------------------------------------*
1198 <TC - Stop operation in altstep without runs on clause>
1202 <MODULE TTCN ModuleA ModuleA.ttcn>
1204 altstep MyAltstep(inout timer T) {
1205 [] T.timeout { self.stop; }
1210 <RESULT IF_PASS NEGATIVE>
1216 .*---------------------------------------------------------------------*
1217 :h4.Stop operation in function without runs on clause
1218 .*---------------------------------------------------------------------*
1221 <TC - Stop operation in function without runs on clause>
1225 <MODULE TTCN ModuleA ModuleA.ttcn>
1233 <RESULT IF_PASS NEGATIVE>
1239 .*---------------------------------------------------------------------*
1240 :h4.Stop operation in control part
1241 .*---------------------------------------------------------------------*
1244 <TC - Stop operation in control part>
1248 <MODULE TTCN ModuleA ModuleA.ttcn>
1251 if (false) { stop; }
1256 <RESULT IF_PASS COUNT 2>
1259 <RESULT IF_PASS COUNT 1>
1262 <RESULT IF_PASS COUNT 1>
1263 (?is)\bComponent\b.+?\boperation\b
1265 <RESULT IF_PASS POSITIVE>
1266 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1272 .*---------------------------------------------------------------------*
1273 :h3.Sending/receiving local component definitions SA-9/12
1274 .*---------------------------------------------------------------------*
1275 Requirement: Sending/receiving local component definitions.
1277 :nl.Data types containing information that is only valid within the same
1278 :nl.component type (e.g. default references) are called local data types.
1279 :nl.These types cannot be sent or received via ports.
1280 .*---------------------------------------------------------------------*
1281 :h4.Sending local component definitions
1282 .*---------------------------------------------------------------------*
1285 <TC - Sending local component definitions>
1289 <MODULE TTCN ModuleA ModuleA.ttcn>
1291 type record MyStruct { integer field1, default field2 }
1292 type port MyPortType message { inout MyStruct }
1293 type component MyComp1 { port MyPortType MyPort; }
1295 altstep MyDefault(inout MyPortType loc_port) {
1296 [] loc_port.trigger { }
1299 function MyFunc1() runs on MyComp1 {
1300 var MyStruct MyWar := { field1 := 0, field2 := activate(MyDefault(MyPort)) }
1305 <RESULT IF_FAIL COUNT 1>
1308 <RESULT IF_FAIL POSITIVE>
1309 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1313 .*---------------------------------------------------------------------*
1314 :h4.Receiving local component definitions
1315 .*---------------------------------------------------------------------*
1318 <TC - Receiving local component definitions>
1322 <MODULE TTCN ModuleA ModuleA.ttcn>
1324 type record MyStruct { integer field1, default field2 }
1325 type port MyPortType message { inout MyStruct }
1326 type component MyComp2 { port MyPortType MyPort; }
1328 altstep MyDefault(inout MyPortType loc_port) {
1329 [] loc_port.trigger { }
1332 function MyFunc2() runs on MyComp2 {
1333 var MyStruct MyWar := { field1 := 0, field2 := activate(MyDefault(MyPort)) }
1335 [] MyPort.receive(?) -> value MyWar { deactivate(MyWar.field2); }
1340 <RESULT IF_FAIL COUNT 1>
1343 <RESULT IF_FAIL POSITIVE>
1344 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1349 .*---------------------------------------------------------------------*
1350 :h3.Activate->Timers in the parameter list of an activated altstep SA-9/13
1351 .*---------------------------------------------------------------------*
1352 Requirement: Timers in the parameter list of an activated altstep.
1354 :nl.All timer instances in the actual parameter list shall be declared as
1355 :nl.component type local timers.
1356 .*---------------------------------------------------------------------*
1357 :h4.Activate->Timers in the parameter list of an activated altstep with runs on
1358 .*---------------------------------------------------------------------*
1361 <TC - Activate->Timers in the parameter list of an activated altstep with runs on>
1365 <MODULE TTCN ModuleA ModuleA.ttcn>
1367 type port MyPortType message { inout integer }
1368 type component MyComp { port MyPortType MyPort; }
1370 altstep MyAltstep1(inout MyPortType loc_port, inout timer loc_timer)
1372 [] loc_port.trigger { }
1373 [] loc_timer.timeout { }
1376 function MyFunc() runs on MyComp {
1378 // TR 700: SA-1.69Timers and variables passed by reference in the parameter list of an activated altstep
1379 activate(MyAltstep1(MyPort, loc_timer));
1383 <RESULT IF_FAIL COUNT 1>
1386 <RESULT IF_PASS COUNT 1>
1387 (?is)\bParameter\b.+?\brefers\b.+?\blocal\b
1389 <RESULT IF_FAIL POSITIVE>
1390 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1396 .*---------------------------------------------------------------------*
1397 :h4.Activate->Timers in the parameter list of an activated altstep without runs on
1398 .*---------------------------------------------------------------------*
1401 <TC - Activate->Timers in the parameter list of an activated altstep without runs on>
1405 <MODULE TTCN ModuleA ModuleA.ttcn>
1407 type port MyPortType message { inout integer }
1408 type component MyComp { port MyPortType MyPort; }
1410 altstep MyAltstep2(inout MyPortType loc_port, inout timer loc_timer) {
1411 [] loc_port.trigger { }
1412 [] loc_timer.timeout { }
1415 function MyFunc() runs on MyComp {
1417 // TR 700: SA-1.69Timers and variables passed by reference in the parameter list of an activated altstep
1418 activate(MyAltstep2(MyPort, loc_timer));
1422 <RESULT IF_FAIL COUNT 1>
1425 <RESULT IF_PASS COUNT 1>
1426 (?is)\bParameter\b.+?\brefers\b.+?\blocal\b
1428 <RESULT IF_FAIL POSITIVE>
1429 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1436 .*---------------------------------------------------------------------*
1437 :h3.Communication operations->Exceptions timeout SA-9/14
1438 .*---------------------------------------------------------------------*
1439 Requirement: Exceptions.
1441 :nl. Catching timeout exceptions shall be restricted to the exception
1442 :nl.handling part of a call. No further matching criteria (including a
1443 :nl.from part) and no assignment part is allowed for a catch operation
1444 :nl.that handles a timeout exception.
1445 .*---------------------------------------------------------------------*
1446 :h4.Communication operations->Exceptions->Timeout with assignment
1447 .*---------------------------------------------------------------------*
1450 <TC - Communication operations->Exceptions->Timeout with assignment>
1454 <MODULE TTCN ModuleA ModuleA.ttcn>
1456 signature MySig_block();
1457 type port MyPortType1 procedure { inout MySig_block}
1458 type component MyComp {
1459 port MyPortType1 MyPort1;
1461 function MyAltstep1(MyComp loc_par) runs on MyComp {
1463 MyPort1.call(MySig_block:{},20E-3) {
1464 [] MyPort1.catch(timeout) -> sender MyWar1 {}
1469 <RESULT IF_PASS COUNT 1>
1472 <RESULT IF_PASS POSITIVE>
1473 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1477 .*---------------------------------------------------------------------*
1478 :h4.Communication operations->Exceptions->Timeout with from statement
1479 .*---------------------------------------------------------------------*
1482 <TC - Communication operations->Exceptions->Timeout with from statement>
1486 <MODULE TTCN ModuleA ModuleA.ttcn>
1488 signature MySig_block();
1489 type port MyPortType1 procedure { inout MySig_block}
1490 type component MyComp {
1491 port MyPortType1 MyPort1;
1493 function MyAltstep1(MyComp loc_par) runs on MyComp {
1495 MyPort1.call(MySig_block:{},20E-3) {
1496 [] MyPort1.catch(timeout) from self {}
1501 <RESULT IF_PASS COUNT 1>
1504 <RESULT IF_PASS POSITIVE>
1505 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1510 .*---------------------------------------------------------------------*
1511 :h3.Verdict operations SA-9/15
1512 .*---------------------------------------------------------------------*
1513 Requirement: Verdict operations.
1515 :nl.The setverdict operation shall only be used with the values pass,
1516 :nl.fail, inconc and none.
1517 :nl.NOTE only the direct assignments can be checked by SA.
1518 .*---------------------------------------------------------------------*
1519 :h4.Verdict operations
1520 .*---------------------------------------------------------------------*
1523 <TC - Verdict operations>
1527 <MODULE TTCN ModuleA ModuleA.ttcn>
1529 type component MyComp {}
1530 function MyFunc1() runs on MyComp {
1535 <RESULT IF_PASS COUNT 1>
1536 (?is)\bError\b.+?\bverdict\b.+?\bset\b
1538 <RESULT IF_PASS POSITIVE>
1539 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1545 .*---------------------------------------------------------------------*
1546 :h3.Checking of ports on connect and map operations SA-9/17
1547 .*---------------------------------------------------------------------*
1548 Requirement: Invalid value is used as component reference.
1550 :nl.If a messages/signature can be sent/called on one of the ports of a
1551 :nl.map or connect operation, it has to be listed in the in or inout list
1552 :nl.of the other port.
1553 .*---------------------------------------------------------------------*
1554 :h4.Connect operation, incorrect port type
1555 .*---------------------------------------------------------------------*
1558 <TC - Connect operation, incorrect port type>
1562 <MODULE TTCN ModuleA ModuleA.ttcn>
1565 type port MyPortType1 message { inout boolean }
1566 type port MyPortType2 procedure { inout MySig }
1567 type component MyComp {
1568 port MyPortType1 MyPort1;
1569 port MyPortType2 MyPort2;
1571 function MyFunc1() runs on MyComp {
1572 connect(self:MyPort1,self:MyPort2);
1576 <RESULT IF_PASS COUNT 1>
1579 <RESULT IF_PASS COUNT 1>
1580 (?im)\bconnection\b.+?\bnot\b.+?\bconsistent\b
1582 <RESULT IF_PASS POSITIVE>
1583 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1588 .*---------------------------------------------------------------------*
1589 :h4.Connect operation, incorrect signature list case 1
1590 .*---------------------------------------------------------------------*
1593 <TC - Connect operation, incorrect signature list case 1>
1597 <MODULE TTCN ModuleA ModuleA.ttcn>
1601 type port MyPortType1 procedure { inout MySig,MySig2 }
1602 type port MyPortType2 procedure { inout MySig }
1603 type component MyComp {
1604 port MyPortType1 MyPort1;
1605 port MyPortType2 MyPort2;
1607 function MyFunc1() runs on MyComp {
1608 connect(self:MyPort1,self:MyPort2);
1612 <RESULT IF_PASS COUNT 1>
1615 <RESULT IF_PASS COUNT 1>
1616 (?im)\bconnection\b.+?\bnot\b.+?\bconsistent\b
1618 <RESULT IF_PASS COUNT 1>
1619 (?im)\bnot\b.+?\bpresent\b
1621 <RESULT IF_PASS POSITIVE>
1622 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1627 .*---------------------------------------------------------------------*
1628 :h4.Connect operation, incorrect signature list case 2
1629 .*---------------------------------------------------------------------*
1632 <TC - Connect operation, incorrect signature list case 2>
1636 <MODULE TTCN ModuleA ModuleA.ttcn>
1640 type port MyPortType1 procedure { out MySig,MySig2 }
1641 type port MyPortType2 procedure { in MySig2 out MySig }
1642 type component MyComp {
1643 port MyPortType1 MyPort1;
1644 port MyPortType2 MyPort2;
1646 function MyFunc1() runs on MyComp {
1647 connect(self:MyPort1,self:MyPort2);
1651 <RESULT IF_PASS COUNT 1>
1654 <RESULT IF_PASS COUNT 1>
1655 (?im)\bconnection\b.+?\bnot\b.+?\bconsistent\b
1657 <RESULT IF_PASS COUNT 2>
1658 (?im)\bnot\b.+?\bpresent\b
1660 <RESULT IF_PASS POSITIVE>
1661 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1666 .*---------------------------------------------------------------------*
1667 :h4.Map operation, incorrect signature list case 3
1668 .*---------------------------------------------------------------------*
1671 <TC - Map operation, incorrect signature list case 3>
1675 <MODULE TTCN ModuleA ModuleA.ttcn>
1679 type port MyPortType1 procedure { out MySig,MySig2 }
1680 type port MyPortType2 procedure { in MySig2 out MySig }
1681 type component MyComp {
1682 port MyPortType1 MyPort1;
1683 port MyPortType2 MyPort2;
1685 testcase MyFunc1() runs on MyComp {
1686 map(self:MyPort1,system:MyPort2);
1690 <RESULT IF_PASS COUNT 1>
1693 <RESULT IF_PASS COUNT 1>
1694 (?im)\bmapping\b.+?\bnot\b.+?\bconsistent\b
1696 <RESULT IF_PASS COUNT 2>
1697 (?im)\bnot\b.+?\bpresent\b
1699 <RESULT IF_PASS POSITIVE>
1700 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1705 .*---------------------------------------------------------------------*
1706 :h4.Connect operation, incorrect variable list case 1
1707 .*---------------------------------------------------------------------*
1710 <TC - Connect operation, incorrect variable list case 1>
1714 <MODULE TTCN ModuleA ModuleA.ttcn>
1716 type port MyPortType1 message { inout integer,octetstring }
1717 type port MyPortType2 message { inout integer }
1718 type component MyComp {
1719 port MyPortType1 MyPort1;
1720 port MyPortType2 MyPort2;
1722 function MyFunc1() runs on MyComp {
1723 connect(self:MyPort1,self:MyPort2);
1727 <RESULT IF_PASS COUNT 1>
1730 <RESULT IF_PASS COUNT 1>
1731 (?im)\bconnection\b.+?\bnot\b.+?\bconsistent\b
1733 <RESULT IF_PASS COUNT 1>
1734 (?im)\bnot\b.+?\bpresent\b
1736 <RESULT IF_PASS POSITIVE>
1737 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1742 .*---------------------------------------------------------------------*
1743 :h4.Connect operation, incorrect variable list case 2
1744 .*---------------------------------------------------------------------*
1747 <TC - Connect operation, incorrect variable list case 2>
1751 <MODULE TTCN ModuleA ModuleA.ttcn>
1753 type port MyPortType1 message { out integer,octetstring }
1754 type port MyPortType2 message { in octetstring out integer }
1755 type component MyComp {
1756 port MyPortType1 MyPort1;
1757 port MyPortType2 MyPort2;
1759 function MyFunc1() runs on MyComp {
1760 connect(self:MyPort1,self:MyPort2);
1764 <RESULT IF_PASS COUNT 1>
1767 <RESULT IF_PASS COUNT 1>
1768 (?im)\bconnection\b.+?\bnot\b.+?\bconsistent\b
1770 <RESULT IF_PASS COUNT 2>
1771 (?im)\bnot\b.+?\bpresent\b
1773 <RESULT IF_PASS POSITIVE>
1774 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1779 .*---------------------------------------------------------------------*
1780 :h4.Map operation, incorrect variable list case 3
1781 .*---------------------------------------------------------------------*
1784 <TC - Map operation, incorrect variable list case 3>
1788 <MODULE TTCN ModuleA ModuleA.ttcn>
1790 type port MyPortType1 message { out integer,octetstring }
1791 type port MyPortType2 message { in octetstring out integer }
1792 type component MyComp {
1793 port MyPortType1 MyPort1;
1794 port MyPortType2 MyPort2;
1796 testcase MyFunc1() runs on MyComp {
1797 map(self:MyPort1,system:MyPort2);
1801 <RESULT IF_PASS COUNT 1>
1804 <RESULT IF_PASS COUNT 1>
1805 (?im)\bmapping\b.+?\bnot\b.+?\bconsistent\b
1807 <RESULT IF_PASS COUNT 2>
1808 (?im)\bnot\b.+?\bpresent\b
1810 <RESULT IF_PASS POSITIVE>
1811 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1817 .*---------------------------------------------------------------------*
1818 :h3.The Select Case statement
1819 .*---------------------------------------------------------------------*
1820 :nl.This test case group covers the requirement SA-9/18.
1822 :nl.- All templateInstance in all list branches shall be of a type compatible
1823 with the type of the expression in the header. A list branch is selected
1824 and the block of statements of the selected branch is executed only, if
1825 any of the templateInstance matches the value of the expression in the
1826 header of the statement. On executing the block of statements of the
1827 selected branch (i.e. not jumping out by a go to statement), execution
1828 continues with the statement following the select case statement.
1829 :nl.- The block of statements of an else branch is always executed if no other
1830 branch textually preceding the else branch has been selected.
1832 .*---------------------------------------------------------------------*
1833 :h4.TTCN-3::SelectCase->control part: with integer
1834 .*---------------------------------------------------------------------*
1836 <TC - TTCN-3::SelectCase->control part: with integer>
1840 <MODULE TTCN ModuleA ModuleA.ttcn>
1843 integer tsp_int := 1;
1846 var integer vl_int := 0;
1849 case (0) { vl_int := tsp_int + 10; }
1850 case (1,3) { vl_int := tsp_int + 100; }
1851 case (5,9) { vl_int := tsp_int + 1000; }
1852 case else { vl_int := tsp_int + 2000 }
1854 log("Result: ", vl_int);
1858 <RESULT IF_PASS NEGATIVE>
1861 <RESULT IF_PASS POSITIVE>
1862 (?im)\bnotify\b.+?\bGenerating\b.+?\bcode\b
1868 .*---------------------------------------------------------------------*
1869 :h4.TTCN-3::SelectCase->else branch: not at the end
1870 .*---------------------------------------------------------------------*
1872 <TC - TTCN-3::SelectCase->else branch: not at the end>
1876 <MODULE TTCN ModuleA ModuleA.ttcn>
1879 integer tsp_int := 1;
1882 var integer vl_int := 0;
1885 case (0) { vl_int := tsp_int + 10; }
1886 case (1,3) { vl_int := tsp_int + 100; }
1887 case else { vl_int := tsp_int + 2000 }
1888 case (5,9) { vl_int := tsp_int + 1000; }
1889 case else { vl_int := tsp_int + 2000 }
1891 log("Result: ", vl_int);
1895 <RESULT IF_PASS NEGATIVE>
1898 <RESULT IF_PASS COUNT 2>
1899 (?im)\bwarning\b.+?Control.+?never.+?reaches.+?previous
1901 <RESULT IF_PASS POSITIVE>
1902 (?im)\bnotify\b.+?\bGenerating\b.+?\bcode\b
1907 .*---------------------------------------------------------------------*
1908 :h4.TTCN-3::SelectCase->expression: timer
1909 .*---------------------------------------------------------------------*
1911 <TC - TTCN-3::SelectCase->expression: timer>
1915 <MODULE TTCN ModuleA ModuleA.ttcn>
1917 type component CT {}
1918 testcase TC() runs on CT {
1922 case (0.4,1.2) { setverdict(pass); }
1923 case else { setverdict(fail); }
1926 control { execute(TC()); }
1928 //error: Reference to a value was expected instead of timer `vl_T1'
1930 <RESULT IF_PASS COUNT 1>
1931 (?im)\berror\b.+?Reference.+?was.+?expected
1933 <RESULT IF_PASS POSITIVE>
1934 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1940 .*---------------------------------------------------------------------*
1941 :h4.TTCN-3::SelectCase->control part: octetstring instead of integer
1942 .*---------------------------------------------------------------------*
1944 <TC - TTCN-3::SelectCase->control part: octetstring instead of integer>
1948 <MODULE TTCN ModuleA ModuleA.ttcn>
1951 integer tsp_int := 3;
1954 var integer vl_int := 0;
1955 var charstring vl_charstr := "ja";
1959 { vl_int := tsp_int + 10; }
1960 case (1, 3, vl_charstr)
1961 { vl_int := tsp_int + 100; }
1962 case (5, 9, 'A5'O, vl_int)
1963 { vl_int := tsp_int + 1000; }
1965 { vl_int := tsp_int + 2000 }
1967 log("Result: ", vl_int);
1971 <RESULT IF_PASS COUNT 1>
1972 (?im)\berror\b.+?Type.+?mismatch.+?integer.+?was.+?expected
1974 <RESULT IF_PASS COUNT 2>
1975 (?im)\berror\b.+?integer.+?was.+?expected
1977 <RESULT IF_PASS POSITIVE>
1978 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1984 .*---------------------------------------------------------------------*
1985 :h4.TTCN-3::SelectCase->function: bitstring instead of charstring
1986 .*---------------------------------------------------------------------*
1988 <TC - TTCN-3::SelectCase->function: bitstring instead of charstring>
1992 <MODULE TTCN ModuleA ModuleA.ttcn>
1995 integer tsp_int := 3;
1997 function F( in charstring charstr ) return integer
1999 var integer vl_int := 0;
2000 var charstring vl_charstr := "ja";
2004 { vl_int := tsp_int + 10; }
2005 case ("ha", vl_charstr)
2006 { vl_int := tsp_int + 100; }
2007 case ("huha", "aha", '111010111'B)
2008 { vl_int := tsp_int + 1000; }
2010 { vl_int := tsp_int + 2000 }
2017 var integer vl_int := -1;
2020 case (0) { vl_int := F("sdf"); }
2021 case (3,vl_int) { vl_int := F("ja"); }
2022 case (5,9) { vl_int := F("aha"); }
2023 case else { vl_int := F("sdfuu"); }
2025 log("Result: ", vl_int);
2029 <RESULT IF_PASS COUNT 1>
2030 (?im)\berror\b.+?character string.+?was.+?expected
2032 <RESULT IF_PASS POSITIVE>
2033 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2039 .*---------------------------------------------------------------------*
2040 :h4.TTCN-3::SelectCase->altstep: float instead of octetstring
2041 .*---------------------------------------------------------------------*
2043 <TC - TTCN-3::SelectCase->altstep: float instead of octetstring>
2047 <MODULE TTCN ModuleA ModuleA.ttcn>
2050 integer tsp_int := 3;
2052 altstep A( in octetstring octet )
2054 var integer vl_int := 0;
2055 var octetstring vl_octet := 'AB56FF'O;
2057 select (octet & 'FF'O)
2059 case ('1F'O & 'FF'O)
2060 { vl_int := tsp_int + 10; }
2061 case ('A9'O, vl_octet)
2062 { vl_int := tsp_int + 100; }
2063 case ('C5'O, 'CC'O, 5.6)
2064 { vl_int := tsp_int + 1000; }
2066 { vl_int := tsp_int + 2000 }
2068 log("Result: ", vl_int);
2073 var integer vl_int := -1;
2076 case (0) { A('FF'O); }
2077 case (3,vl_int) { A('A9'O); }
2078 case (5,9) { A('CC'O); }
2079 case else { A('1F'O); }
2084 <RESULT IF_PASS COUNT 1>
2085 (?im)\berror\b.+?octetstring.+?was.+?expected
2087 <RESULT IF_PASS POSITIVE>
2088 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2094 .*---------------------------------------------------------------------*
2095 :h4.TTCN-3::SelectCase->function_runs_on: float instead of integer
2096 .*---------------------------------------------------------------------*
2098 <TC - TTCN-3::SelectCase->function_runs_on: float instead of integer>
2102 <MODULE TTCN ModuleA ModuleA.ttcn>
2105 float tsp_float := 1.9;
2106 integer tsp_int := 3;
2108 type component CT {}
2109 function F() runs on CT return integer
2111 var integer vl_int := 0;
2112 var float vl_float := 0.8;
2113 select (float2int(tsp_float) * tsp_int)
2115 case (5 * float2int(vl_float))
2116 { vl_int := tsp_int + 10; }
2118 { vl_int := tsp_int + 100; }
2120 { vl_int := tsp_int + 1000; }
2122 { vl_int := tsp_int + 2000; }
2126 testcase TC() runs on CT
2128 log("Result: ", F());
2130 control { execute ( TC() ); }
2133 <RESULT IF_PASS COUNT 1>
2134 (?im)\berror\b.+?Type.+?mismatch.+?integer.+?was.+?expected
2136 <RESULT IF_PASS POSITIVE>
2137 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2143 .*---------------------------------------------------------------------*
2144 :h4.TTCN-3::SelectCase->altstep_runs_on: octet instead of bitstring
2145 .*---------------------------------------------------------------------*
2147 <TC - TTCN-3::SelectCase->altstep_runs_on: octet instead of bitstring>
2151 <MODULE TTCN ModuleA ModuleA.ttcn>
2154 integer tsp_int := 9;
2155 bitstring tsp_bitstring := '11010'B;
2157 type component CT {}
2158 altstep A() runs on CT
2161 var bitstring vl_bitstring := '111011010'B;
2163 select ('1110'B & tsp_bitstring)
2165 case ('1001'B, vl_bitstring)
2166 { vl_int := tsp_int + 10; }
2167 case ('1100'B, '11'O)
2168 { vl_int := tsp_int + 100; }
2169 case ('11011'B, '10'B, '111'B)
2170 { vl_int := tsp_int + 1000; }
2172 { vl_int := tsp_int + 2000; }
2174 log("Result: ", vl_int);
2177 testcase TC() runs on CT { A() }
2178 control { execute ( TC() ); }
2181 <RESULT IF_PASS COUNT 1>
2182 (?im)\berror\b.+?bitstring.+?was.+?expected
2184 <RESULT IF_PASS POSITIVE>
2185 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2191 .*---------------------------------------------------------------------*
2192 :h4.TTCN-3::SelectCase->testcase: integer instead of enum
2193 .*---------------------------------------------------------------------*
2195 <TC - TTCN-3::SelectCase->testcase: integer instead of enum>
2199 <MODULE TTCN ModuleA ModuleA.ttcn>
2202 integer tsp_int := 9;
2205 type enumerated Enum { A,B,C,D,E,F,G }
2206 type component CT {}
2207 testcase TC() runs on CT
2210 var integer vl_H := 5;
2211 var Enum vl_enum := B;
2215 { vl_int := tsp_int + 10; }
2217 { vl_int := tsp_int + 100; }
2219 { vl_int := tsp_int + 1000; }
2221 { vl_int := tsp_int + 2000; }
2223 log("Result: ", vl_int);
2225 control { execute ( TC() ); }
2228 <RESULT IF_PASS COUNT 1>
2229 (?im)\berror\b.+?Type.+?mismatch.+?Enum.+?was.+?expected
2231 <RESULT IF_PASS POSITIVE>
2232 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2238 .*---------------------------------------------------------------------*
2239 :h4.TTCN-3::SelectCase->control part: scope
2240 .*---------------------------------------------------------------------*
2242 <TC - TTCN-3::SelectCase->control part: scope>
2246 <MODULE TTCN ModuleA ModuleA.ttcn>
2249 integer tsp_int := 1;
2252 var integer vl_int := 0;
2257 vl_int := tsp_int + 100;
2258 var integer vl_emb := vl_int * 5;
2265 log("Result: ", vl_int);
2266 log("Embedded: ", vl_emb);
2270 <RESULT IF_PASS COUNT 1>
2271 (?im)\berror\b.+?no.+?local.+?or.+?imported.+?definition.+?vl_emb
2273 <RESULT IF_PASS POSITIVE>
2274 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2280 .*---------------------------------------------------------------------*
2281 :h4.TTCN-3::SelectCase->control part: identifier overloading
2282 .*---------------------------------------------------------------------*
2284 <TC - TTCN-3::SelectCase->control part: identifier overloading>
2288 <MODULE TTCN ModuleA ModuleA.ttcn>
2291 integer tsp_int := 1;
2294 var integer vl_int := 0;
2300 var integer tsp_int := vl_int * 5;
2307 log("Result: ", vl_int);
2311 <RESULT IF_PASS COUNT 1>
2312 (?im)\berror\b.+?tsp_int.+?not.+?unique
2314 <RESULT IF_PASS COUNT 1>
2315 (?im)\bnote\b.+?tsp_int.+?higher.+?scope
2317 <RESULT IF_PASS COUNT 1>
2320 <RESULT IF_PASS POSITIVE>
2321 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2327 .*---------------------------------------------------------------------*
2328 :h4.TTCN-3::SelectCase->control part: goto-label
2329 .*---------------------------------------------------------------------*
2331 <TC - TTCN-3::SelectCase->control part: goto-label>
2335 <MODULE TTCN ModuleA ModuleA.ttcn>
2338 integer tsp_int := 1;
2341 var integer vl_int := 0;
2355 log("Result: ", vl_int);
2359 <RESULT IF_PASS COUNT 1>
2360 (?im)\berror\b.+?Label.+?L1.+?not.+?defined
2362 <RESULT IF_PASS COUNT 1>
2365 <RESULT IF_PASS POSITIVE>
2366 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2372 .*---------------------------------------------------------------------*
2373 :h4.TTCN-3::SelectCase->Syntax error_1
2374 .*---------------------------------------------------------------------*
2376 <TC - TTCN-3::SelectCase->Syntax error_1>
2380 <MODULE TTCN ModuleA ModuleA.ttcn>
2383 integer tsp_int := 1;
2386 var integer vl_int := 0;
2400 <RESULT IF_PASS COUNT 2>
2401 (?im)\berror\b.+?syntax.+?error
2403 <RESULT IF_PASS COUNT 2>
2406 <RESULT IF_PASS POSITIVE>
2407 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2413 .*---------------------------------------------------------------------*
2414 :h4.TTCN-3::SelectCase->Syntax error_2
2415 .*---------------------------------------------------------------------*
2417 <TC - TTCN-3::SelectCase->Syntax error_2>
2421 <MODULE TTCN ModuleA ModuleA.ttcn>
2424 integer tsp_int := 1;
2427 var integer vl_int := 0;
2442 <RESULT IF_PASS COUNT 1>
2443 (?im)\berror\b.+?syntax.+?error
2445 <RESULT IF_PASS COUNT 1>
2448 <RESULT IF_PASS POSITIVE>
2449 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2455 .*---------------------------------------------------------------------*
2456 :h4.TTCN-3::SelectCase->Syntax error_3
2457 .*---------------------------------------------------------------------*
2459 <TC - TTCN-3::SelectCase->Syntax error_3>
2463 <MODULE TTCN ModuleA ModuleA.ttcn>
2466 integer tsp_int := 1;
2469 var integer vl_int := 0;
2482 <RESULT IF_PASS COUNT 1>
2483 (?im)\berror\b.+?syntax.+?error
2485 <RESULT IF_PASS COUNT 1>
2488 <RESULT IF_PASS POSITIVE>
2489 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2495 .*---------------------------------------------------------------------*
2496 :h4.TTCN-3::SelectCase->Syntax error_4
2497 .*---------------------------------------------------------------------*
2499 <TC - TTCN-3::SelectCase->Syntax error_4>
2503 <MODULE TTCN ModuleA ModuleA.ttcn>
2506 integer tsp_int := 1;
2509 var integer vl_int := 0;
2524 <RESULT IF_PASS COUNT 2>
2525 (?im)\berror\b.+?syntax.+?error
2527 <RESULT IF_PASS COUNT 2>
2530 <RESULT IF_PASS POSITIVE>
2531 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2538 .*---------------------------------------------------------------------*
2539 :h3.Configuration Operations
2540 .*---------------------------------------------------------------------*
2541 :nl.This test case group covers the requirement SA-9/19.
2543 :nl.- These operations shall only be used in TTCN-3 testcases, functions
2544 and altsteps (i.e. not in the module control part).
2545 :nl.- The done and killed operations shall not be used in a boolean
2546 expression (i.e. in the if condition ).
2547 :nl.- The alive and running operations shall not be used to determine an
2548 alternative (i.e. in the alt condition).
2549 :nl.- Create operation: optionally, a name can be associated with the newly
2550 created component instance. The name shall be a charstring value.
2552 .*---------------------------------------------------------------------*
2553 :h4.TTCN-3::ConfigOper->create in the control part
2554 .*---------------------------------------------------------------------*
2556 <TC - TTCN-3::ConfigOper->create in the control part>
2560 <MODULE TTCN ModuleA ModuleA.ttcn>
2562 type component ct {};
2564 var ct comp := ct.create;
2565 var ct comp1 := ct.create alive;
2569 <RESULT IF_PASS COUNT 2>
2570 (?im)\berror\b.+?create.+?not.+?allowed.+?control.+?part
2572 <RESULT IF_PASS COUNT 2>
2575 <RESULT IF_PASS POSITIVE>
2576 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2582 .*---------------------------------------------------------------------*
2583 :h4.TTCN-3::ConfigOper->start operation in the control part
2584 .*---------------------------------------------------------------------*
2586 <TC - TTCN-3::ConfigOper->start operation in the control part>
2590 <MODULE TTCN ModuleA ModuleA.ttcn>
2592 type component ct {};
2593 function f() runs on ct {};
2600 <RESULT IF_PASS COUNT 1>
2601 (?im)\berror\b.+?Component.+?operation.+?not.+?allowed.+?control.+?part
2603 <RESULT IF_PASS COUNT 1>
2606 <RESULT IF_PASS POSITIVE>
2607 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2613 .*---------------------------------------------------------------------*
2614 :h4.TTCN-3::ConfigOper->stop operation in the control part
2615 .*---------------------------------------------------------------------*
2617 <TC - TTCN-3::ConfigOper->stop operation in the control part>
2621 <MODULE TTCN ModuleA ModuleA.ttcn>
2623 type component ct {};
2630 <RESULT IF_PASS COUNT 1>
2631 (?im)\berror\b.+?Component.+?operation.+?not.+?allowed.+?control.+?part
2633 <RESULT IF_PASS COUNT 1>
2636 <RESULT IF_PASS POSITIVE>
2637 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2643 .*---------------------------------------------------------------------*
2644 :h4.TTCN-3::ConfigOper->all-stop operation in the control part
2645 .*---------------------------------------------------------------------*
2647 <TC - TTCN-3::ConfigOper->all-stop operation in the control part>
2651 <MODULE TTCN ModuleA ModuleA.ttcn>
2653 type component ct {};
2660 <RESULT IF_PASS COUNT 1>
2661 (?im)\berror\b.+?syntax.+?error
2663 <RESULT IF_PASS COUNT 1>
2666 <RESULT IF_PASS POSITIVE>
2667 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2673 .*---------------------------------------------------------------------*
2674 :h4.TTCN-3::ConfigOper->kill operation in the control part
2675 .*---------------------------------------------------------------------*
2677 <TC - TTCN-3::ConfigOper->kill operation in the control part>
2681 <MODULE TTCN ModuleA ModuleA.ttcn>
2683 type component ct {};
2690 <RESULT IF_PASS COUNT 1>
2691 (?im)\berror\b.+?syntax.+?error
2693 <RESULT IF_PASS COUNT 1>
2696 <RESULT IF_PASS POSITIVE>
2697 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2703 .*---------------------------------------------------------------------*
2704 :h4.TTCN-3::ConfigOper->all-kill operation in the control part
2705 .*---------------------------------------------------------------------*
2707 <TC - TTCN-3::ConfigOper->all-kill operation in the control part>
2711 <MODULE TTCN ModuleA ModuleA.ttcn>
2713 type component ct {};
2720 <RESULT IF_PASS COUNT 1>
2721 (?im)\berror\b.+?syntax.+?error
2723 <RESULT IF_PASS COUNT 1>
2726 <RESULT IF_PASS POSITIVE>
2727 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2733 .*---------------------------------------------------------------------*
2734 :h4.TTCN-3::ConfigOper->alive operation in the control part
2735 .*---------------------------------------------------------------------*
2737 <TC - TTCN-3::ConfigOper->alive operation in the control part>
2741 <MODULE TTCN ModuleA ModuleA.ttcn>
2743 type component ct {};
2750 <RESULT IF_PASS COUNT 1>
2751 (?im)\berror\b.+?Operation.+?not.+?allowed.+?control.+?part
2753 <RESULT IF_PASS COUNT 1>
2756 <RESULT IF_PASS POSITIVE>
2757 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2763 .*---------------------------------------------------------------------*
2764 :h4.TTCN-3::ConfigOper->any-alive operation in the control part
2765 .*---------------------------------------------------------------------*
2767 <TC - TTCN-3::ConfigOper->any-alive operation in the control part>
2771 <MODULE TTCN ModuleA ModuleA.ttcn>
2773 type component ct {};
2776 if (any component.alive) {};
2780 <RESULT IF_PASS COUNT 1>
2781 (?im)\berror\b.+?Operation.+?not.+?allowed.+?control.+?part
2783 <RESULT IF_PASS COUNT 1>
2786 <RESULT IF_PASS POSITIVE>
2787 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2794 .*---------------------------------------------------------------------*
2795 :h4.TTCN-3::ConfigOper->all-alive operation in the control part
2796 .*---------------------------------------------------------------------*
2798 <TC - TTCN-3::ConfigOper->all-alive operation in the control part>
2802 <MODULE TTCN ModuleA ModuleA.ttcn>
2804 type component ct {};
2807 if (all component.alive) {};
2811 <RESULT IF_PASS COUNT 1>
2812 (?im)\berror\b.+?Operation.+?not.+?allowed.+?control.+?part
2814 <RESULT IF_PASS COUNT 1>
2817 <RESULT IF_PASS POSITIVE>
2818 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2824 .*---------------------------------------------------------------------*
2825 :h4.TTCN-3::ConfigOper->running operation in the control part
2826 .*---------------------------------------------------------------------*
2828 <TC - TTCN-3::ConfigOper->running operation in the control part>
2832 <MODULE TTCN ModuleA ModuleA.ttcn>
2834 type component ct {};
2837 if (comp.running) {}
2841 <RESULT IF_PASS COUNT 1>
2842 (?im)\berror\b.+?Operation.+?not.+?allowed.+?control.+?part
2844 <RESULT IF_PASS COUNT 1>
2847 <RESULT IF_PASS POSITIVE>
2848 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2854 .*---------------------------------------------------------------------*
2855 :h4.TTCN-3::ConfigOper->any-running operation in the control part
2856 .*---------------------------------------------------------------------*
2858 <TC - TTCN-3::ConfigOper->any-running operation in the control part>
2862 <MODULE TTCN ModuleA ModuleA.ttcn>
2864 type component ct {};
2867 if (any component.running) {};
2871 <RESULT IF_PASS COUNT 1>
2872 (?im)\berror\b.+?Operation.+?not.+?allowed.+?control.+?part
2874 <RESULT IF_PASS COUNT 1>
2877 <RESULT IF_PASS POSITIVE>
2878 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2885 .*---------------------------------------------------------------------*
2886 :h4.TTCN-3::ConfigOper->all-running operation in the control part
2887 .*---------------------------------------------------------------------*
2889 <TC - TTCN-3::ConfigOper->all-running operation in the control part>
2893 <MODULE TTCN ModuleA ModuleA.ttcn>
2895 type component ct {};
2898 if (all component.running) {};
2902 <RESULT IF_PASS COUNT 1>
2903 (?im)\berror\b.+?Operation.+?not.+?allowed.+?control.+?part
2905 <RESULT IF_PASS COUNT 1>
2908 <RESULT IF_PASS POSITIVE>
2909 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2915 .*---------------------------------------------------------------------*
2916 :h4.TTCN-3::ConfigOper->done operation in the control part
2917 .*---------------------------------------------------------------------*
2919 <TC - TTCN-3::ConfigOper->done operation in the control part>
2923 <MODULE TTCN ModuleA ModuleA.ttcn>
2925 type component ct {};
2928 alt { [] comp.done {} }
2932 <RESULT IF_PASS COUNT 1>
2933 (?im)\berror\b.+?Component.+?operation.+?not.+?allowed.+?control.+?part
2935 <RESULT IF_PASS COUNT 1>
2938 <RESULT IF_PASS POSITIVE>
2939 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2945 .*---------------------------------------------------------------------*
2946 :h4.TTCN-3::ConfigOper->any-done operation in the control part
2947 .*---------------------------------------------------------------------*
2949 <TC - TTCN-3::ConfigOper->any-done operation in the control part>
2953 <MODULE TTCN ModuleA ModuleA.ttcn>
2955 type component ct {};
2958 alt { [] any component.done {} }
2962 <RESULT IF_PASS COUNT 1>
2963 (?im)\berror\b.+?Component.+?operation.+?not.+?allowed.+?control.+?part
2965 <RESULT IF_PASS COUNT 1>
2968 <RESULT IF_PASS POSITIVE>
2969 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2975 .*---------------------------------------------------------------------*
2976 :h4.TTCN-3::ConfigOper->all-done operation in the control part
2977 .*---------------------------------------------------------------------*
2979 <TC - TTCN-3::ConfigOper->all-done operation in the control part>
2983 <MODULE TTCN ModuleA ModuleA.ttcn>
2985 type component ct {};
2988 alt { [] all component.done {} }
2992 <RESULT IF_PASS COUNT 1>
2993 (?im)\berror\b.+?Component.+?operation.+?not.+?allowed.+?control.+?part
2995 <RESULT IF_PASS COUNT 1>
2998 <RESULT IF_PASS POSITIVE>
2999 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3005 .*---------------------------------------------------------------------*
3006 :h4.TTCN-3::ConfigOper->killed operation in the control part
3007 .*---------------------------------------------------------------------*
3009 <TC - TTCN-3::ConfigOper->killed operation in the control part>
3013 <MODULE TTCN ModuleA ModuleA.ttcn>
3015 type component ct {};
3018 alt { [] comp.killed {} }
3022 <RESULT IF_PASS COUNT 1>
3023 (?im)\berror\b.+?Component.+?operation.+?not.+?allowed.+?control.+?part
3025 <RESULT IF_PASS COUNT 1>
3028 <RESULT IF_PASS POSITIVE>
3029 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3035 .*---------------------------------------------------------------------*
3036 :h4.TTCN-3::ConfigOper->any-killed operation in the control part
3037 .*---------------------------------------------------------------------*
3039 <TC - TTCN-3::ConfigOper->any-killed operation in the control part>
3043 <MODULE TTCN ModuleA ModuleA.ttcn>
3045 type component ct {};
3048 alt { [] any component.killed {} }
3052 <RESULT IF_PASS COUNT 1>
3053 (?im)\berror\b.+?Component.+?operation.+?not.+?allowed.+?control.+?part
3055 <RESULT IF_PASS COUNT 1>
3058 <RESULT IF_PASS POSITIVE>
3059 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3065 .*---------------------------------------------------------------------*
3066 :h4.TTCN-3::ConfigOper->all-killed operation in the control part
3067 .*---------------------------------------------------------------------*
3069 <TC - TTCN-3::ConfigOper->all-killed operation in the control part>
3073 <MODULE TTCN ModuleA ModuleA.ttcn>
3075 type component ct {};
3078 alt { [] all component.killed {} }
3082 <RESULT IF_PASS COUNT 1>
3083 (?im)\berror\b.+?Component.+?operation.+?not.+?allowed.+?control.+?part
3085 <RESULT IF_PASS COUNT 1>
3088 <RESULT IF_PASS POSITIVE>
3089 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3095 .*---------------------------------------------------------------------*
3096 :h4.TTCN-3::ConfigOper->connect operation in the control part
3097 .*---------------------------------------------------------------------*
3099 <TC - TTCN-3::ConfigOper->connect operation in the control part>
3103 <MODULE TTCN ModuleA ModuleA.ttcn>
3105 type port Port message { inout integer };
3106 type component ct { port Port port1; }
3107 function f() runs on ct {};
3110 connect(mtc:Port1,comp:Port1);
3114 <RESULT IF_PASS COUNT 1>
3115 (?im)\berror\b.+?syntax.+?error
3117 <RESULT IF_PASS COUNT 1>
3120 <RESULT IF_PASS POSITIVE>
3121 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3127 .*---------------------------------------------------------------------*
3128 :h4.TTCN-3::ConfigOper->disconnect operation in the control part
3129 .*---------------------------------------------------------------------*
3131 <TC - TTCN-3::ConfigOper->disconnect operation in the control part>
3135 <MODULE TTCN ModuleA ModuleA.ttcn>
3137 type port Port message { inout integer };
3138 type component ct { port Port port1; }
3139 function f() runs on ct {};
3142 disconnect(self:Port1,comp:Port1);
3146 <RESULT IF_PASS COUNT 1>
3147 (?im)\berror\b.+?syntax.+?error
3149 <RESULT IF_PASS COUNT 1>
3152 <RESULT IF_PASS POSITIVE>
3153 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3159 .*---------------------------------------------------------------------*
3160 :h4.TTCN-3::ConfigOper->map operation in the control part
3161 .*---------------------------------------------------------------------*
3163 <TC - TTCN-3::ConfigOper->map operation in the control part>
3167 <MODULE TTCN ModuleA ModuleA.ttcn>
3169 type port Port message { inout integer };
3170 type component ct { port Port port1; }
3171 function f() runs on ct {};
3174 map(comp:Port1,system:Port1);
3178 <RESULT IF_PASS COUNT 1>
3179 (?im)\berror\b.+?syntax.+?error
3181 <RESULT IF_PASS COUNT 1>
3184 <RESULT IF_PASS POSITIVE>
3185 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3191 .*---------------------------------------------------------------------*
3192 :h4.TTCN-3::ConfigOper->unmap operation in the control part
3193 .*---------------------------------------------------------------------*
3195 <TC - TTCN-3::ConfigOper->unmap operation in the control part>
3199 <MODULE TTCN ModuleA ModuleA.ttcn>
3201 type port Port message { inout integer };
3202 type component ct { port Port port1; }
3203 function f() runs on ct {};
3206 unmap(comp:Port1,system:Port1);
3210 <RESULT IF_PASS COUNT 1>
3211 (?im)\berror\b.+?syntax.+?error
3213 <RESULT IF_PASS COUNT 1>
3216 <RESULT IF_PASS POSITIVE>
3217 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3223 .*---------------------------------------------------------------------*
3224 :h4.TTCN-3::ConfigOper->stop operation in the if condition
3225 .*---------------------------------------------------------------------*
3227 <TC - TTCN-3::ConfigOper->stop operation in the if condition>
3231 <MODULE TTCN ModuleA ModuleA.ttcn>
3233 type component ct {}
3234 testcase tc() runs on ct {
3235 var ct comp:=ct.create alive;
3240 <RESULT IF_PASS COUNT 1>
3241 (?im)\berror\b.+?syntax.+?error
3243 <RESULT IF_PASS COUNT 1>
3246 <RESULT IF_PASS POSITIVE>
3247 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3253 .*---------------------------------------------------------------------*
3254 :h4.TTCN-3::ConfigOper->all-stop operation in the if condition
3255 .*---------------------------------------------------------------------*
3257 <TC - TTCN-3::ConfigOper->all-stop operation in the if condition>
3261 <MODULE TTCN ModuleA ModuleA.ttcn>
3263 type component ct {}
3264 testcase tc() runs on ct {
3265 var ct comp:=ct.create alive;
3266 if ( all component.stop ) {}
3270 <RESULT IF_PASS COUNT 1>
3271 (?im)\berror\b.+?syntax.+?error
3273 <RESULT IF_PASS COUNT 1>
3276 <RESULT IF_PASS POSITIVE>
3277 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3283 .*---------------------------------------------------------------------*
3284 :h4.TTCN-3::ConfigOper->kill operation in the if condition
3285 .*---------------------------------------------------------------------*
3287 <TC - TTCN-3::ConfigOper->kill operation in the if condition>
3291 <MODULE TTCN ModuleA ModuleA.ttcn>
3293 type component ct {}
3294 testcase tc() runs on ct {
3295 var ct comp:=ct.create alive;
3300 <RESULT IF_PASS COUNT 1>
3301 (?im)\berror\b.+?syntax.+?error
3303 <RESULT IF_PASS COUNT 1>
3306 <RESULT IF_PASS POSITIVE>
3307 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3313 .*---------------------------------------------------------------------*
3314 :h4.TTCN-3::ConfigOper->all-kill operation in the if condition
3315 .*---------------------------------------------------------------------*
3317 <TC - TTCN-3::ConfigOper->all-kill operation in the if condition>
3321 <MODULE TTCN ModuleA ModuleA.ttcn>
3323 type component ct {}
3324 testcase tc() runs on ct {
3325 var ct comp:=ct.create alive;
3326 if ( all component.kill ) {}
3330 <RESULT IF_PASS COUNT 1>
3331 (?im)\berror\b.+?syntax.+?error
3333 <RESULT IF_PASS COUNT 1>
3336 <RESULT IF_PASS POSITIVE>
3337 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3343 .*---------------------------------------------------------------------*
3344 :h4.TTCN-3::ConfigOper->done operation in the if condition
3345 .*---------------------------------------------------------------------*
3347 <TC - TTCN-3::ConfigOper->done operation in the if condition>
3351 <MODULE TTCN ModuleA ModuleA.ttcn>
3353 type component ct {}
3354 testcase tc() runs on ct {
3355 var ct comp:=ct.create alive;
3360 <RESULT IF_PASS COUNT 1>
3361 (?im)\berror\b.+?syntax.+?error
3363 <RESULT IF_PASS COUNT 1>
3366 <RESULT IF_PASS POSITIVE>
3367 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3373 .*---------------------------------------------------------------------*
3374 :h4.TTCN-3::ConfigOper->any-done operation in the if condition
3375 .*---------------------------------------------------------------------*
3377 <TC - TTCN-3::ConfigOper->any-done operation in the if condition>
3381 <MODULE TTCN ModuleA ModuleA.ttcn>
3383 type component ct {}
3384 testcase tc() runs on ct {
3385 var ct comp:=ct.create alive;
3386 if ( any component.done ) {}
3390 <RESULT IF_PASS COUNT 1>
3391 (?im)\berror\b.+?syntax.+?error
3393 <RESULT IF_PASS COUNT 1>
3396 <RESULT IF_PASS POSITIVE>
3397 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3403 .*---------------------------------------------------------------------*
3404 :h4.TTCN-3::ConfigOper->all-done operation in the if condition
3405 .*---------------------------------------------------------------------*
3407 <TC - TTCN-3::ConfigOper->all-done operation in the if condition>
3411 <MODULE TTCN ModuleA ModuleA.ttcn>
3413 type component ct {}
3414 testcase tc() runs on ct {
3415 var ct comp:=ct.create alive;
3416 if ( all component.done ) {}
3420 <RESULT IF_PASS COUNT 1>
3421 (?im)\berror\b.+?syntax.+?error
3423 <RESULT IF_PASS COUNT 1>
3426 <RESULT IF_PASS POSITIVE>
3427 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3433 .*---------------------------------------------------------------------*
3434 :h4.TTCN-3::ConfigOper->killed operation in the if condition
3435 .*---------------------------------------------------------------------*
3437 <TC - TTCN-3::ConfigOper->killed operation in the if condition>
3441 <MODULE TTCN ModuleA ModuleA.ttcn>
3443 type component ct {}
3444 testcase tc() runs on ct {
3445 var ct comp:=ct.create alive;
3446 if ( comp.killed ) {}
3450 <RESULT IF_PASS COUNT 1>
3451 (?im)\berror\b.+?syntax.+?error
3453 <RESULT IF_PASS COUNT 1>
3456 <RESULT IF_PASS POSITIVE>
3457 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3463 .*---------------------------------------------------------------------*
3464 :h4.TTCN-3::ConfigOper->any-killed operation in the if condition
3465 .*---------------------------------------------------------------------*
3467 <TC - TTCN-3::ConfigOper->any-killed operation in the if condition>
3471 <MODULE TTCN ModuleA ModuleA.ttcn>
3473 type component ct {}
3474 testcase tc() runs on ct {
3475 var ct comp:=ct.create alive;
3476 if ( any component.killed ) {}
3480 <RESULT IF_PASS COUNT 1>
3481 (?im)\berror\b.+?syntax.+?error
3483 <RESULT IF_PASS COUNT 1>
3486 <RESULT IF_PASS POSITIVE>
3487 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3493 .*---------------------------------------------------------------------*
3494 :h4.TTCN-3::ConfigOper->all-killed operation in the if condition
3495 .*---------------------------------------------------------------------*
3497 <TC - TTCN-3::ConfigOper->all-killed operation in the if condition>
3501 <MODULE TTCN ModuleA ModuleA.ttcn>
3503 type component ct {}
3504 testcase tc() runs on ct {
3505 var ct comp:=ct.create alive;
3506 if ( all component.killed ) {}
3510 <RESULT IF_PASS COUNT 1>
3511 (?im)\berror\b.+?syntax.+?error
3513 <RESULT IF_PASS COUNT 1>
3516 <RESULT IF_PASS POSITIVE>
3517 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3523 .*---------------------------------------------------------------------*
3524 :h4.TTCN-3::ConfigOper->stop operation in the alt condition
3525 .*---------------------------------------------------------------------*
3527 <TC - TTCN-3::ConfigOper->stop operation in the alt condition>
3531 <MODULE TTCN ModuleA ModuleA.ttcn>
3533 type component ct {}
3534 testcase tc() runs on ct {
3535 var ct comp:=ct.create alive;
3536 alt { [] comp.stop {} }
3540 <RESULT IF_PASS COUNT 2>
3541 (?im)\berror\b.+?syntax.+?error
3543 <RESULT IF_PASS COUNT 2>
3546 <RESULT IF_PASS POSITIVE>
3547 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3553 .*---------------------------------------------------------------------*
3554 :h4.TTCN-3::ConfigOper->all-stop operation in the alt condition
3555 .*---------------------------------------------------------------------*
3557 <TC - TTCN-3::ConfigOper->all-stop operation in the alt condition>
3561 <MODULE TTCN ModuleA ModuleA.ttcn>
3563 type component ct {}
3564 testcase tc() runs on ct {
3565 var ct comp:=ct.create alive;
3566 alt { [] all component.stop {} }
3570 <RESULT IF_PASS COUNT 2>
3571 (?im)\berror\b.+?syntax.+?error
3573 <RESULT IF_PASS COUNT 2>
3576 <RESULT IF_PASS POSITIVE>
3577 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3583 .*---------------------------------------------------------------------*
3584 :h4.TTCN-3::ConfigOper->kill operation in the alt condition
3585 .*---------------------------------------------------------------------*
3587 <TC - TTCN-3::ConfigOper->kill operation in the alt condition>
3591 <MODULE TTCN ModuleA ModuleA.ttcn>
3593 type component ct {}
3594 testcase tc() runs on ct {
3595 var ct comp:=ct.create alive;
3596 alt { [] comp.kill {} }
3600 <RESULT IF_PASS COUNT 2>
3601 (?im)\berror\b.+?syntax.+?error
3603 <RESULT IF_PASS COUNT 2>
3606 <RESULT IF_PASS POSITIVE>
3607 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3613 .*---------------------------------------------------------------------*
3614 :h4.TTCN-3::ConfigOper->all-kill operation in the alt condition
3615 .*---------------------------------------------------------------------*
3617 <TC - TTCN-3::ConfigOper->all-kill operation in the alt condition>
3621 <MODULE TTCN ModuleA ModuleA.ttcn>
3623 type component ct {}
3624 testcase tc() runs on ct {
3625 var ct comp:=ct.create alive;
3626 alt { [] all component.kill {} }
3630 <RESULT IF_PASS COUNT 2>
3631 (?im)\berror\b.+?syntax.+?error
3633 <RESULT IF_PASS COUNT 2>
3636 <RESULT IF_PASS POSITIVE>
3637 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3643 .*---------------------------------------------------------------------*
3644 :h4.TTCN-3::ConfigOper->alive operation in the alt condition
3645 .*---------------------------------------------------------------------*
3647 <TC - TTCN-3::ConfigOper->alive operation in the alt condition>
3651 <MODULE TTCN ModuleA ModuleA.ttcn>
3653 type component ct {}
3654 testcase tc() runs on ct {
3655 var ct comp:=ct.create alive;
3656 alt { [] comp.alive {} }
3660 <RESULT IF_PASS COUNT 2>
3661 (?im)\berror\b.+?syntax.+?error
3663 <RESULT IF_PASS COUNT 2>
3666 <RESULT IF_PASS POSITIVE>
3667 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3673 .*---------------------------------------------------------------------*
3674 :h4.TTCN-3::ConfigOper->any-alive operation in the alt condition
3675 .*---------------------------------------------------------------------*
3677 <TC - TTCN-3::ConfigOper->any-alive operation in the alt condition>
3681 <MODULE TTCN ModuleA ModuleA.ttcn>
3683 type component ct {}
3684 testcase tc() runs on ct {
3685 var ct comp:=ct.create alive;
3686 alt { [] any component.alive {} }
3690 <RESULT IF_PASS COUNT 2>
3691 (?im)\berror\b.+?syntax.+?error
3693 <RESULT IF_PASS COUNT 2>
3696 <RESULT IF_PASS POSITIVE>
3697 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3703 .*---------------------------------------------------------------------*
3704 :h4.TTCN-3::ConfigOper->all-alive operation in the alt condition
3705 .*---------------------------------------------------------------------*
3707 <TC - TTCN-3::ConfigOper->all-alive operation in the alt condition>
3711 <MODULE TTCN ModuleA ModuleA.ttcn>
3713 type component ct {}
3714 testcase tc() runs on ct {
3715 var ct comp:=ct.create alive;
3716 alt { [] all component.alive {} }
3720 <RESULT IF_PASS COUNT 2>
3721 (?im)\berror\b.+?syntax.+?error
3723 <RESULT IF_PASS COUNT 2>
3726 <RESULT IF_PASS POSITIVE>
3727 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3733 .*---------------------------------------------------------------------*
3734 :h4.TTCN-3::ConfigOper->running operation in the alt condition
3735 .*---------------------------------------------------------------------*
3737 <TC - TTCN-3::ConfigOper->running operation in the alt condition>
3741 <MODULE TTCN ModuleA ModuleA.ttcn>
3743 type component ct {}
3744 testcase tc() runs on ct {
3745 var ct comp:=ct.create alive;
3746 alt { [] comp.running {} }
3750 <RESULT IF_PASS COUNT 2>
3751 (?im)\berror\b.+?syntax.+?error
3753 <RESULT IF_PASS COUNT 2>
3756 <RESULT IF_PASS POSITIVE>
3757 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3763 .*---------------------------------------------------------------------*
3764 :h4.TTCN-3::ConfigOper->any-running operation in the alt condition
3765 .*---------------------------------------------------------------------*
3767 <TC - TTCN-3::ConfigOper->any-running operation in the alt condition>
3771 <MODULE TTCN ModuleA ModuleA.ttcn>
3773 type component ct {}
3774 testcase tc() runs on ct {
3775 var ct comp:=ct.create alive;
3776 alt { [] any component.running {} }
3780 <RESULT IF_PASS COUNT 2>
3781 (?im)\berror\b.+?syntax.+?error
3783 <RESULT IF_PASS COUNT 2>
3786 <RESULT IF_PASS POSITIVE>
3787 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3793 .*---------------------------------------------------------------------*
3794 :h4.TTCN-3::ConfigOper->all-running operation in the alt condition
3795 .*---------------------------------------------------------------------*
3797 <TC - TTCN-3::ConfigOper->all-running operation in the alt condition>
3801 <MODULE TTCN ModuleA ModuleA.ttcn>
3803 type component ct {}
3804 testcase tc() runs on ct {
3805 var ct comp:=ct.create alive;
3806 alt { [] all component.running {} }
3810 <RESULT IF_PASS COUNT 2>
3811 (?im)\berror\b.+?syntax.+?error
3813 <RESULT IF_PASS COUNT 2>
3816 <RESULT IF_PASS POSITIVE>
3817 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3823 .*---------------------------------------------------------------------*
3824 :h4.TTCN-3::ConfigOper->create name is not charstring
3825 .*---------------------------------------------------------------------*
3827 <TC - TTCN-3::ConfigOper->create name is not charstring>
3831 <MODULE TTCN ModuleA ModuleA.ttcn>
3833 type component ct {};
3835 var ct comp := ct.create (5);
3836 var ct comp1 := ct.create ('01001'B) alive;
3839 var ct comp := ct.create ('3C'O);
3840 var ct comp1 := ct.create (false) alive;
3843 testcase tc() runs on ct {
3844 var ct comp := ct.create (5.6);
3845 var ct comp1 := ct.create ('ffb9a'H) alive;
3849 <RESULT IF_PASS COUNT 6>
3850 (?im)\berror\b.+?First.+?operand.+?should.+?be.+?charstring
3852 <RESULT IF_PASS COUNT 6>
3855 <RESULT IF_PASS POSITIVE>
3856 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3862 .*---------------------------------------------------------------------*
3863 :h4.TTCN-3::ConfigOper->Scope: component variable - create alive
3864 .*---------------------------------------------------------------------*
3866 <TC - TTCN-3::ConfigOper->Scope: component variable - create alive>
3870 <MODULE TTCN ModuleA ModuleA.ttcn>
3872 type component ct {};
3873 testcase tc() runs on ct {
3875 var ct comp := ct.create ("alive") alive;
3877 if ( comp.alive ) {}
3881 <RESULT IF_PASS COUNT 1>
3882 (?im)\berror\b.+?no.+?local.+?or.+?imported.+?definition.+?comp
3884 <RESULT IF_PASS COUNT 1>
3887 <RESULT IF_PASS POSITIVE>
3888 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3895 .*---------------------------------------------------------------------*
3896 :h3.The Interleave statement
3897 .*---------------------------------------------------------------------*
3898 :nl.This test case group covers the requirement SA-9/20.
3900 :nl.- The interleave statement allows to specify the interleaved occurrence
3901 :nl. and handling of the statements done, killed, timeout, receive, trigger,
3902 getcall, catch and check.
3903 :nl.- Control transfer statements for, while, do-while, goto, stop, repeat,
3904 :nl. return, activate, deactivate, direct call of altsteps as alternatives
3905 :nl. and (direct and indirect) calls of user-defined functions, which include
3906 :nl. communication operations, shall not be used in interleave statements.
3907 :nl.- It is not allowed to guard branches of an interleave statement with
3908 Boolean expressions (i.e. the '[ ]' shall always be empty).
3909 :nl. It is also not allowed to specify else branches in interleaved behaviour.
3911 :p. TTCN-3 language extensions:
3912 :nl.- Loop constructs for, while and do-while loops are accepted and supported
3913 without any restriction in interleave statements.
3914 :nl.- Statements activate, deactivate and stop can also be used within interleave.
3915 :nl.- The compiler does not check whether a TTCN
\963 function invoked from within
3916 an interleave statement has side-effects. The run-time behaviour is undefined
3917 if a function with side-effects (e.g. communication operations) is called
3918 while an interleave statement is being executed.
3919 :nl.- The statement block is optional after the guard operations of interleave
3920 constructs. A missing statement block has the same meaning as an empty
3921 statement block. If the statement block is omitted a terminating semi-colon
3922 must be present after the guard statement.
3924 .*---------------------------------------------------------------------*
3925 :h4.TTCN-3::Interleave-> standard statements (done,killed,timeout,receive)
3926 .*---------------------------------------------------------------------*
3928 <TC - TTCN-3::Interleave-> standard statements (done,killed,timeout,receive)>
3932 <MODULE TTCN ModuleA ModuleA.ttcn>
3934 type port Port message { inout integer } with { extension "internal" };
3939 template integer M1 := ?;
3943 var ct comp :=ct.create;
3944 var ct comp1:=ct.create;
3948 [] any component.done {}
3949 [] all component.done {}
3951 [] any component.killed {}
3952 [] all component.killed {}
3953 [] any port.receive {}
3958 var ct comp :=ct.create;
3959 var ct comp1:=ct.create;
3964 [] any component.done {}
3965 [] all component.done {}
3967 [] any component.killed {}
3968 [] all component.killed {}
3969 [] any port.receive {}
3973 function ff() runs on ct {
3974 var ct comp :=ct.create;
3975 var ct comp1:=ct.create;
3979 [] any component.done {}
3980 [] all component.done {}
3982 [] any component.killed {}
3983 [] all component.killed {}
3984 [] P1.receive(M1) {}
3985 [] any port.receive {}
3988 altstep aa() runs on ct {
3989 var ct comp :=ct.create;
3990 var ct comp1:=ct.create;
3995 [] any component.done {}
3996 [] all component.done {}
3998 [] any component.killed {}
3999 [] all component.killed {}
4000 [] P1.receive(M1) {}
4001 [] any port.receive {}
4005 testcase tc() runs on ct {
4006 var ct comp :=ct.create;
4007 var ct comp1:=ct.create;
4011 [] any component.done {}
4012 [] all component.done {}
4014 [] any component.killed {}
4015 [] all component.killed {}
4016 [] P1.receive(M1) {}
4017 [] any port.receive {}
4028 <RESULT IF_PASS NEGATIVE>
4031 <RESULT IF_PASS POSITIVE>
4032 (?im)\bnotify\b.+?\bGenerating\b.+?\bcode\b
4038 .*---------------------------------------------------------------------*
4039 :h4.TTCN-3::Interleave-> standard statements (trigger,getcall,catch,check)
4040 .*---------------------------------------------------------------------*
4042 <TC - TTCN-3::Interleave-> standard statements (trigger,getcall,catch,check)>
4046 <MODULE TTCN ModuleA ModuleA.ttcn>
4048 signature MySig() exception (integer);
4049 type port PortM message { inout integer } with { extension "internal" };
4050 type port PortP procedure { inout MySig } with { extension "internal" };
4056 template integer M1 := ?;
4060 [] any port.trigger {}
4061 [] any port.catch {}
4062 [] any port.getreply {}
4063 [] any port.getcall {}
4064 [] any port.check {}
4070 [] any port.trigger {}
4071 [] any port.catch {}
4072 [] any port.getreply {}
4073 [] any port.getcall {}
4074 [] any port.check {}
4078 function ff() runs on ct {
4080 [] P1.trigger(M1) {}
4081 [] any port.trigger {}
4082 [] P2.catch(MySig, omit) {}
4083 [] any port.catch {}
4084 [] P2.getreply(MySig:{}) {}
4085 [] any port.getreply {}
4086 [] P2.getcall(MySig:{}) {}
4087 [] any port.getcall {}
4088 [] P2.check(catch(MySig, omit)) {}
4089 [] any port.check {}
4092 altstep aa() runs on ct {
4095 [] P1.trigger(M1) {}
4096 [] any port.trigger {}
4097 [] P2.catch(MySig, omit) {}
4098 [] any port.catch {}
4099 [] P2.getreply(MySig:{}) {}
4100 [] any port.getreply {}
4101 [] P2.getcall(MySig:{}) {}
4102 [] any port.getcall {}
4103 [] P2.check(getreply(MySig:{})) {}
4104 [] any port.check {}
4108 testcase tc() runs on ct {
4110 [] P1.trigger(M1) {}
4111 [] any port.trigger {}
4112 [] P2.catch(MySig, omit) {}
4113 [] any port.catch {}
4114 [] P2.getreply(MySig:{}) {}
4115 [] any port.getreply {}
4116 [] P2.getcall(MySig:{}) {}
4117 [] any port.getcall {}
4118 [] P2.check(getcall(MySig:{})) {}
4119 [] any port.check {}
4124 <RESULT IF_PASS NEGATIVE>
4127 <RESULT IF_PASS POSITIVE>
4128 (?im)\bnotify\b.+?\bGenerating\b.+?\bcode\b
4134 .*---------------------------------------------------------------------*
4135 :h4.TTCN-3::Interleave-> extensions statements (for,while,do-while loops)
4136 .*---------------------------------------------------------------------*
4138 <TC - TTCN-3::Interleave-> extensions statements (for,while,do-while loops)>
4142 <MODULE TTCN ModuleA ModuleA.ttcn>
4144 signature MySig() exception (integer);
4145 type port PortM message { inout integer } with { extension "internal" };
4146 type port PortP procedure { inout MySig } with { extension "internal" };
4152 template integer M1 := ?;
4157 [] any port.trigger { for (j:=1; j<100; j:=j+1) {c:=c+j} }
4158 [] any port.catch { while (c<100) {c:=c+1} }
4159 [] any port.getreply { do { c:=c+1 } while (c<100); }
4166 [] any port.trigger { for (j:=1; j<100; j:=j+1) {c:=c+j} }
4167 [] any port.catch { while (c<100) {c:=c+1} }
4168 [] any port.getreply { do { c:=c+1 } while (c<100); }
4172 function ff() runs on ct {
4174 [] P1.trigger(M1) { for (i:=1; i<100; i:=i+1) {c:=c+i} }
4175 [] P2.catch(MySig, omit) { while (c<100) {c:=c+1} }
4176 [] P2.getreply(MySig:{}) { do { c:=c+1 } while (c<100); }
4179 altstep aa() runs on ct {
4182 [] P1.trigger(M1) { for (i:=1; i<100; i:=i+1) {c:=c+i} }
4183 [] P2.catch(MySig, omit) { while (c<100) {c:=c+1} }
4184 [] P2.getreply(MySig:{}) { do { c:=c+1 } while (c<100); }
4188 testcase tc() runs on ct {
4190 [] P1.trigger(M1) { for (i:=1; i<100; i:=i+1) {c:=c+i} }
4191 [] P2.catch(MySig, omit) { while (c<100) {c:=c+1} }
4192 [] P2.getreply(MySig:{}) { do { c:=c+1 } while (c<100); }
4197 <RESULT IF_PASS NEGATIVE>
4200 <RESULT IF_PASS POSITIVE>
4201 (?im)\bnotify\b.+?\bGenerating\b.+?\bcode\b
4207 .*---------------------------------------------------------------------*
4208 :h4.TTCN-3::Interleave-> extensions statements (activate,deactivate,stop)
4209 .*---------------------------------------------------------------------*
4211 <TC - TTCN-3::Interleave-> extensions statements (activate,deactivate,stop)>
4215 <MODULE TTCN ModuleA ModuleA.ttcn>
4217 signature MySig() exception (integer);
4218 type port PortM message { inout integer } with { extension "internal" };
4219 type port PortP procedure { inout MySig } with { extension "internal" };
4223 var default vd_DefaultVar := null;
4225 template integer M1 := ?;
4229 var default vd_DefaultVar1 := null;
4231 [] T.timeout { vd_DefaultVar1 := activate(MyDefAltstep()); }
4232 [] any port.getcall { deactivate(vd_DefaultVar1); }
4233 [] any port.receive { stop; }
4238 var default vd_DefaultVar1 := null;
4241 [] T.timeout { vd_DefaultVar1 := activate(MyDefAltstep()); }
4242 [] any port.getcall { deactivate(vd_DefaultVar1); }
4243 [] any port.receive { stop; }
4247 function ff() runs on ct {
4249 [] P1.receive(M1) { vd_DefaultVar := activate(MyDefAltstep()); }
4250 [] P2.check(getreply(MySig:{})) { deactivate(vd_DefaultVar); }
4251 [] P2.getcall(MySig:{}) { stop; }
4254 altstep aa() runs on ct {
4257 [] P1.receive(M1) { vd_DefaultVar := activate(MyDefAltstep()); }
4258 [] P2.check(getreply(MySig:{})) { deactivate(vd_DefaultVar); }
4259 [] P2.getcall(MySig:{}) { stop; }
4263 testcase tc() runs on ct {
4265 [] P1.receive(M1) { vd_DefaultVar := activate(MyDefAltstep()); }
4266 [] P2.check(getreply(MySig:{})) { deactivate(vd_DefaultVar); }
4267 [] P2.getcall(MySig:{}) { stop; }
4270 altstep MyDefAltstep() { [else] {}; }
4273 <RESULT IF_PASS NEGATIVE>
4276 <RESULT IF_PASS POSITIVE>
4277 (?im)\bnotify\b.+?\bGenerating\b.+?\bcode\b
4283 .*---------------------------------------------------------------------*
4284 :h4.TTCN-3::Interleave-> function with communication statement
4285 .*---------------------------------------------------------------------*
4287 <TC - TTCN-3::Interleave-> function with communication statement>
4291 <MODULE TTCN ModuleA ModuleA.ttcn>
4293 signature MySig() exception (integer);
4294 type port PortP procedure { inout MySig } with { extension "internal" };
4299 function f() runs on ct {
4301 [] P1.getreply(MySig:{}) {}
4304 testcase tc() runs on ct {
4305 var ct comp :=ct.create;
4308 [] comp.done { f(); }
4314 <RESULT IF_PASS NEGATIVE>
4317 <RESULT IF_PASS POSITIVE>
4318 (?im)\bnotify\b.+?\bGenerating\b.+?\bcode\b
4324 .*---------------------------------------------------------------------*
4325 :h4.TTCN-3::Interleave-> statement block is optional
4326 .*---------------------------------------------------------------------*
4328 <TC - TTCN-3::Interleave-> statement block is optional>
4332 <MODULE TTCN ModuleA ModuleA.ttcn>
4334 signature MySig() exception (integer);
4335 type port PortM message { inout integer } with { extension "internal" };
4336 type port PortP procedure { inout MySig } with { extension "internal" };
4342 template integer M1 := ?;
4343 testcase tc() runs on ct {
4344 var ct comp :=ct.create;
4348 [] any component.done;
4349 [] all component.done;
4351 [] any component.killed;
4352 [] all component.killed;
4354 [] any port.receive;
4356 [] any port.trigger;
4357 [] P2.catch(MySig, omit);
4359 [] P2.getreply(MySig:{});
4360 [] any port.getreply;
4361 [] P2.getcall(MySig:{});
4362 [] any port.getcall;
4363 [] P2.check(getcall(MySig:{}));
4369 <RESULT IF_PASS NEGATIVE>
4372 <RESULT IF_PASS POSITIVE>
4373 (?im)\bnotify\b.+?\bGenerating\b.+?\bcode\b
4379 .*---------------------------------------------------------------------*
4380 :h4.TTCN-3::Interleave-> guard_expression
4381 .*---------------------------------------------------------------------*
4383 <TC - TTCN-3::Interleave-> guard_expression>
4387 <MODULE TTCN ModuleA ModuleA.ttcn>
4389 type component ct {}
4390 function f(inout integer x) {
4392 var ct comp :=ct.create;
4399 function ff(inout integer x) runs on ct {
4401 var ct comp :=ct.create;
4408 testcase tc(inout integer x) runs on ct {
4410 var ct comp :=ct.create;
4419 <RESULT IF_PASS COUNT 3>
4420 (?im)\berror\b.+?x.+?syntax.+?error
4422 <RESULT IF_PASS COUNT 3>
4425 <RESULT IF_PASS POSITIVE>
4426 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4432 .*---------------------------------------------------------------------*
4433 :h4.TTCN-3::Interleave-> else
4434 .*---------------------------------------------------------------------*
4436 <TC - TTCN-3::Interleave-> else>
4440 <MODULE TTCN ModuleA ModuleA.ttcn>
4442 type component ct {}
4446 var ct comp :=ct.create;
4453 function ff() runs on ct {
4455 var ct comp :=ct.create;
4462 testcase tc() runs on ct {
4464 var ct comp :=ct.create;
4468 [else] comp.killed {}
4473 <RESULT IF_PASS COUNT 2>
4474 (?im)\berror\b.+?else.+?syntax.+?error
4476 <RESULT IF_PASS COUNT 2>
4479 <RESULT IF_PASS POSITIVE>
4480 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4486 .*---------------------------------------------------------------------*
4487 :h4.TTCN-3::Interleave-> repeat
4488 .*---------------------------------------------------------------------*
4490 <TC - TTCN-3::Interleave-> repeat>
4494 <MODULE TTCN ModuleA ModuleA.ttcn>
4496 type component ct {}
4498 testcase tc() runs on ct {
4500 var ct comp :=ct.create;
4503 [] comp.done { repeat; }
4509 <RESULT IF_PASS COUNT 1>
4510 (?im)\berror\b.+?Repeat.+?not.+?allowed.+?interleave
4512 <RESULT IF_PASS COUNT 2>
4515 <RESULT IF_PASS POSITIVE>
4516 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4522 .*---------------------------------------------------------------------*
4523 :h4.TTCN-3::Interleave-> goto
4524 .*---------------------------------------------------------------------*
4526 <TC - TTCN-3::Interleave-> goto>
4530 <MODULE TTCN ModuleA ModuleA.ttcn>
4532 type component ct {}
4534 testcase tc() runs on ct {
4536 var ct comp :=ct.create;
4538 [] T.timeout { goto L1; }
4546 <RESULT IF_PASS COUNT 1>
4547 (?im)\berror\b.+?Goto.+?not.+?allowed.+?interleave
4549 <RESULT IF_PASS COUNT 1>
4552 <RESULT IF_PASS POSITIVE>
4553 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4558 .*---------------------------------------------------------------------*
4559 :h4.TTCN-3::Interleave-> label
4560 .*---------------------------------------------------------------------*
4562 <TC - TTCN-3::Interleave-> label>
4566 <MODULE TTCN ModuleA ModuleA.ttcn>
4568 type component ct {}
4570 testcase tc() runs on ct {
4572 var ct comp :=ct.create;
4576 [] comp.done { label L1; }
4582 <RESULT IF_PASS COUNT 1>
4583 (?im)\berror\b.+?Label.+?L1.+?not.+?defined
4585 <RESULT IF_PASS COUNT 1>
4586 (?im)\berror\b.+?Label.+?not.+?allowed.+?interleave
4588 <RESULT IF_PASS COUNT 2>
4591 <RESULT IF_PASS POSITIVE>
4592 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4598 .*---------------------------------------------------------------------*
4599 :h4.TTCN-3::Interleave-> return
4600 .*---------------------------------------------------------------------*
4602 <TC - TTCN-3::Interleave-> return>
4606 <MODULE TTCN ModuleA ModuleA.ttcn>
4608 type component ct {}
4610 function f() runs on ct return integer {
4612 var ct comp :=ct.create;
4614 [] T.timeout { return 5; }
4615 [] comp.done { return 6; }
4616 [] comp.killed { return 7; }
4621 <RESULT IF_PASS COUNT 3>
4622 (?im)\berror\b.+?Return.+?not.+?allowed.+?interleave
4624 <RESULT IF_PASS COUNT 1>
4625 (?im)\berror\b.+?function.+?not.+?have.+?return
4627 <RESULT IF_PASS COUNT 4>
4630 <RESULT IF_PASS POSITIVE>
4631 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4637 .*---------------------------------------------------------------------*
4638 :h4.TTCN-3::Interleave-> altstep
4639 .*---------------------------------------------------------------------*
4641 <TC - TTCN-3::Interleave-> altstep>
4645 <MODULE TTCN ModuleA ModuleA.ttcn>
4647 type component ct {}
4649 testcase tc() runs on ct {
4651 var ct comp :=ct.create;
4664 <RESULT IF_PASS COUNT 1>
4665 (?im)\berror\b.+?altstep.+?syntax.+?error
4667 <RESULT IF_PASS COUNT 2>
4670 <RESULT IF_PASS POSITIVE>
4671 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4677 .*---------------------------------------------------------------------*
4678 :h4.TTCN-3::Interleave-> scope
4679 .*---------------------------------------------------------------------*
4681 <TC - TTCN-3::Interleave-> scope>
4685 <MODULE TTCN ModuleA ModuleA.ttcn>
4687 type component ct { timer T; }
4689 testcase tc() runs on ct {
4690 var ct comp :=ct.create;
4691 var integer vl_int := 1;
4694 var integer vl_emb1 := vl_int * 5;
4698 var integer vl_emb2 := vl_int * 15;
4700 vl_int := vl_emb2 + 1;
4704 log("Result: ", vl_int);
4705 log("Embedded_1: ", vl_emb1);
4706 log("Embedded_2: ", vl_emb2);
4710 <RESULT IF_PASS COUNT 2>
4711 (?im)\berror\b.+?no.+?local.+?or.+?imported.+?definition.+?vl_emb1
4713 <RESULT IF_PASS COUNT 2>
4714 (?im)\berror\b.+?no.+?local.+?or.+?imported.+?definition.+?vl_emb2
4716 <RESULT IF_PASS COUNT 4>
4719 <RESULT IF_PASS POSITIVE>
4720 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4726 .*---------------------------------------------------------------------*
4727 :h4.TTCN-3::Interleave-> identifier overloading
4728 .*---------------------------------------------------------------------*
4730 <TC - TTCN-3::Interleave-> identifier overloading>
4734 <MODULE TTCN ModuleA ModuleA.ttcn>
4738 var integer vl_int := 1;
4741 testcase tc() runs on ct {
4742 var ct comp :=ct.create;
4745 var integer vl_emb := vl_int * 5;
4748 var integer vl_int := 15;
4752 log("Result: ", vl_int);
4756 <RESULT IF_PASS COUNT 1>
4757 (?im)\berror\b.+?vl_int.+?not.+?unique
4759 <RESULT IF_PASS COUNT 1>
4760 (?im)\bnote\b.+?vl_int.+?higher.+?scope
4762 <RESULT IF_PASS COUNT 1>
4765 <RESULT IF_PASS POSITIVE>
4766 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4772 .*---------------------------------------------------------------------*
4773 :h4.TTCN-3::Interleave-> syntax error
4774 .*---------------------------------------------------------------------*
4776 <TC - TTCN-3::Interleave-> syntax error>
4780 <MODULE TTCN ModuleA ModuleA.ttcn>
4782 type component ct { timer T; }
4783 testcase tc() runs on ct {
4784 var ct comp :=ct.create;
4790 function f() runs on ct {
4791 var ct comp :=ct.create;
4798 altstep a() runs on ct {
4799 var ct comp :=ct.create;
4810 <RESULT IF_PASS COUNT 5>
4811 (?im)\berror\b.+?syntax.+?error
4813 <RESULT IF_PASS COUNT 5>
4816 <RESULT IF_PASS POSITIVE>
4817 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4824 .*---------------------------------------------------------------------*
4825 :h3. Redeclaration of a group with a different type
4826 .*---------------------------------------------------------------------*
4828 <TC - Redeclaration of a group with a different type>
4831 <MODULE TTCN ModuleA ModuleA.ttcn>
4840 <RESULT IF_FAIL COUNT 1>
4841 (?im)\berror\b.+Group name .+ clashes with a definition
4846 .*---------------------------------------------------------------------*
4847 :h3. Redeclaration of a group with a different type, reverse order
4848 .*---------------------------------------------------------------------*
4850 <TC - Redeclaration of a group with a different type, reverse order>
4853 <MODULE TTCN ModuleA ModuleA.ttcn>
4862 <RESULT IF_FAIL COUNT 1>
4863 (?im)\berror\b.+Group name .+ clashes with a definition
4868 .*---------------------------------------------------------------------*
4869 :h3. Name clash between type and field
4870 .*---------------------------------------------------------------------*
4872 <TC - Name clash of type and field>
4875 <MODULE TTCN ModuleA ModuleA.ttcn>
4876 module ModuleA { // HL26011
4883 <RESULT IF_FAIL COUNT 1>
4884 (?i)\berror\b: Field name clashes with type name
4889 .*---------------------------------------------------------------------*
4891 .*---------------------------------------------------------------------*
4893 :li D='ASN.1'.Abstract Syntax Notation 1
4894 :li D='EDML'.Ericsson Document Markup Language
4895 :li D='SA'.Semantic Analyser
4896 :li D='TTCN-3'.Test and Test Control Notation version 3
4899 .*---------------------------------------------------------------------*
4901 .*---------------------------------------------------------------------*
4903 :li D='[1]'.3/ETH/RUS-2003:0087 Uen
4904 :nl.Requirement Specification for TITAN's TTCN-3 Semantic Analyser
4905 :li D='[2]'.1/174 02-FCPCA 101 42 Uen
4906 :nl.Statement of Compliance for TITAN project
4907 :li D='[3]'.ETSI ES 201 873-1, v3.0.0 (2005-03):
4908 :nl.Testing and Test Control Notation version 3.,
4909 :nl.Part 1: TTCN-3 Core Language
4912 .*---------------------------------------------------------------------*
4914 .*---------------------------------------------------------------------*
4916 :li D='TITAN'.Ericsson's TTCN-3 Test Environment