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.15/152 91-CRL 113 200/3 Uen
21 :prep.ETH/XZ Jeno Balasko
22 :appr.ETH/XZ (Gyula Koos)
25 :title.Test description of the TTCN-3 Semantic Analyzer: Parameters
27 .*---------------------------------------------------------------------*
29 .*---------------------------------------------------------------------*
30 .*---------------------------------------------------------------------*
32 .*---------------------------------------------------------------------*
34 REV DATE PREPARED CHANGE
35 ________________________________________________________
36 PA1 2005-02-19 ETIBHRA New document for TITAN R6
37 A 2005-03-18 ETIBHRA Approved after review
38 B 2006-07-31 EKRISZA Updates for TITAN R6E
39 C 2007-03-06 EJNOSZA Updates for TITAN R7A (expected error messages)
40 D 2008-10-01 EFERKOV Large integers
41 PE1 2010-03-11 EKRISZA added tests for the fix of TR HL63421
42 E 2010-07-02 EKRISZA version correction.
43 A 2011-12-12 EKRISZA Updated for release
44 A 2012-06-27 EFERKOV Updated for release
45 A 2013-01-17 EKRIPND Updated for release
47 .*---------------------------------------------------------------------*
49 .*---------------------------------------------------------------------*
50 The purpose of this Test Description is to define and describe the function
51 test activity for the Semantic Analyser functionality of the TTCN-3 compiler:
52 :nl.SA-1/4: Parameters.
53 :p.The specification of the test cases can be found in this document.
54 .*---------------------------------------------------------------------*
56 .*---------------------------------------------------------------------*
57 .*---------------------------------------------------------------------*
59 .*---------------------------------------------------------------------*
60 No specific hardware requirement.
61 .*---------------------------------------------------------------------*
63 .*---------------------------------------------------------------------*
64 Tests shall be carried out on the following platforms:
66 :li D='1.'.Solaris 8 (Sun OS 5.8) (gcc 3.0.4)
67 :li D='2.'.SUSE Linux Enterprise server 8 (2.4.19-4GB) (gcc 3.2)
68 :li D='3.'.CYGWIN_NT-5.0 (Cygwin DLL: 1.5.12) on Windows 2000 (gcc 3.3.3)
70 .*---------------------------------------------------------------------*
72 .*---------------------------------------------------------------------*
73 The test environment had been setup in CVS. The tester program is stored in:
74 :nl.TTCNv3/function_test/Tools/SAtester.pl
75 :nl.Test cases are stored with extension .script in the directory:
76 :nl.TTCNv3/function_test/Semantic_Analyser/
77 .*---------------------------------------------------------------------*
79 .*---------------------------------------------------------------------*
80 Install proper TITAN binaries on the used platforms and make sure that
81 your environment settings are correct:
83 :li D='1.'.TTCN3_DIR is set
84 :li D='2.'.$TTCN3_DIR/bin is added to the PATH variable
85 :li D='3.'.$TTCN3_DIR/lib is added to the LD_LIBRARY_PATH variable
86 :li D='4.'.Perl 5.6.0 or higher is available on the platform
87 :li D='5.'.Create a symlink to your Perl binary into the directory where the
88 test cases are stored:
89 :nl.ln -s <your Perl> perl
91 .*---------------------------------------------------------------------*
93 .*---------------------------------------------------------------------*
94 A tester program had been written in Perl especially for the Semantic Analyser
95 tests. For the list of command line parameters, type 'SAtester.pl -help', for the
96 complete documentation, type 'SAtester.pl -doc'.
97 :p.Test cases are specified in the Test Description documents in EDML format.
98 The tester program parses these files and generates the TTCN-3/ASN.1 modules, then
99 calls the compiler to compile them. The result printout is then matched against
100 different patterns to be able to set the verdict. Test cases contain not only
101 the source modules, but the patterns as well.
102 :p.The tester program allows one-by-one execution of test cases and batched
104 :p.NOTE: the tester program requires Perl 5.6.0 or higher.
107 .*---------------------------------------------------------------------*
109 .*---------------------------------------------------------------------*
110 .*---------------------------------------------------------------------*
111 :h2.Parameterization is not allowed
112 .*---------------------------------------------------------------------*
113 This test case group covers the requirement SA-4/1.
115 :nl. Parameterization is not allowed for the following specific language
116 elements: const, var, timer, control, group and import.
121 Hierarchy of scope units
126 MDP: Module Definitons Part
127 MCP: Module Control Part
129 FUN: Function without runs on-clause
130 ALT: Altstep without runs on-clause
131 FWR: Function with runs on-clause
132 AWR: Altstep with runs on-clause
133 TC : Testcase with runs on-clause and optional system-clause
134 BS : Block of statements (within a compound statement)
135 EBS: Embedded block of statements (within a compound statement)
139 _____________________________________________
141 0. _____| MDP |_______
142 | |_____________________________________________| |
143 __|__ __|__ __|__ __|__
145 1. | MCP | ________| CT |________ | FUN | | ALT |
146 |_____| | |_____| | |_____| |_____|
147 | __|__ __|__ __|__ | |
149 2. | | FWR | | AWR | | TC | | |
150 | |_____| |_____| |_____| | |
151 __|__ __|__ __|__ __|__ __|__ __|__
152 | | | | | | | | | | | |
153 3. | BS | | BS | | BS | | BS | | BS | | BS |
154 |_____| |_____| |_____| |_____| |_____| |_____|
155 __|__ __|__ __|__ __|__ __|__ __|__
156 | | | | | | | | | | | |
157 4. | EBS | | EBS | | EBS | | EBS | | EBS | | EBS |
158 |_____| |_____| |_____| |_____| |_____| |_____|
164 Test cases are based on TTCN-3 according to the followings:
165 - We have to check the "const", "var" and "timer" elements.
166 - We checked this elements where we can use firstly in the scope
167 hierarchy and unnecessary to check on the lower levels.
170 The const is checked only in the MDP because another bubbles are
175 .*---------------------------------------------------------------------*
176 :h3.TTCN-3::ParameterizationNotAllowed->Definitions part: const
177 .*---------------------------------------------------------------------*
179 <TC - TTCN-3::ParameterizationNotAllowed->Definitions part: const>
183 <MODULE TTCN ModuleA ModuleA.ttcn>
185 const integer C := 1;
186 const integer CC := C(0);
189 <RESULT IF_PASS COUNT 1>
190 (?im)\berror\b.+?referenced.+?C.+?cannot.+?have.+?parameters
192 <RESULT IF_PASS COUNT 1>
195 <RESULT IF_PASS POSITIVE>
196 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
202 .*---------------------------------------------------------------------*
203 :h3.TTCN-3::ParameterizationNotAllowed->Control part: var
204 .*---------------------------------------------------------------------*
206 <TC - TTCN-3::ParameterizationNotAllowed->Control part: var>
210 <MODULE TTCN ModuleA ModuleA.ttcn>
214 var integer XX := X(0);
218 <RESULT IF_PASS COUNT 1>
219 (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters
221 <RESULT IF_PASS COUNT 1>
224 <RESULT IF_PASS POSITIVE>
225 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
231 .*---------------------------------------------------------------------*
232 :h3.TTCN-3::ParameterizationNotAllowed->Component type: var
233 .*---------------------------------------------------------------------*
235 :nl.The implementation does not support the variable initialized with
236 another variable in the component type (but it would be possible
237 according to TTCN-3 specification ).
241 <TC - TTCN-3::ParameterizationNotAllowed->Component type: var>
245 <MODULE TTCN ModuleA ModuleA.ttcn>
247 type component MyCT {
249 var integer XX := X(0);
253 <RESULT IF_PASS COUNT 1>
254 (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters
256 <RESULT IF_PASS COUNT 1>
257 (?im)\berror\b.+?Reference.+?static.+?value.+?was.+?expected
259 <RESULT IF_PASS COUNT 2>
262 <RESULT IF_PASS POSITIVE>
263 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
269 .*---------------------------------------------------------------------*
270 :h3.TTCN-3::ParameterizationNotAllowed->Component type--Function: var
271 .*---------------------------------------------------------------------*
273 <TC - TTCN-3::ParameterizationNotAllowed->Component type--Function: var>
277 <MODULE TTCN ModuleA ModuleA.ttcn>
279 type component MyCT {
282 function MyCompFunc() runs on MyCT {
283 var integer XX := X(0);
287 <RESULT IF_PASS COUNT 1>
288 (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters
290 <RESULT IF_PASS COUNT 1>
293 <RESULT IF_PASS POSITIVE>
294 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
300 .*---------------------------------------------------------------------*
301 :h3.TTCN-3::ParameterizationNotAllowed->Component type--Altstep: var
302 .*---------------------------------------------------------------------*
304 <TC - TTCN-3::ParameterizationNotAllowed->Component type--Altstep: var>
308 <MODULE TTCN ModuleA ModuleA.ttcn>
310 type component MyCT {
313 altstep MyCompALtstep() runs on MyCT {
314 var integer XX := X(0);
319 <RESULT IF_PASS COUNT 1>
320 (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters
322 <RESULT IF_PASS COUNT 1>
325 <RESULT IF_PASS POSITIVE>
326 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
332 .*---------------------------------------------------------------------*
333 :h3.TTCN-3::ParameterizationNotAllowed->Component type--Testcase: var
334 .*---------------------------------------------------------------------*
336 <TC - TTCN-3::ParameterizationNotAllowed->Component type--Testcase: var>
340 <MODULE TTCN ModuleA ModuleA.ttcn>
342 type component MyCT {
345 testcase MyTestcase() runs on MyCT {
346 var integer XX := X(0);
350 <RESULT IF_PASS COUNT 1>
351 (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters
353 <RESULT IF_PASS COUNT 1>
356 <RESULT IF_PASS POSITIVE>
357 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
363 .*---------------------------------------------------------------------*
364 :h3.TTCN-3::ParameterizationNotAllowed->Function: var
365 .*---------------------------------------------------------------------*
367 <TC - TTCN-3::ParameterizationNotAllowed->Function: var>
371 <MODULE TTCN ModuleA ModuleA.ttcn>
375 var integer XX := X(0);
379 <RESULT IF_PASS COUNT 1>
380 (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters
382 <RESULT IF_PASS COUNT 1>
385 <RESULT IF_PASS POSITIVE>
386 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
392 .*---------------------------------------------------------------------*
393 :h3.TTCN-3::ParameterizationNotAllowed->Altstep: var
394 .*---------------------------------------------------------------------*
396 <TC - TTCN-3::ParameterizationNotAllowed->Altstep: var>
400 <MODULE TTCN ModuleA ModuleA.ttcn>
402 altstep MyAltstep(timer T) {
404 [X(0)>2] T.timeout {};
409 <RESULT IF_PASS COUNT 1>
410 (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters
412 <RESULT IF_PASS COUNT 1>
415 <RESULT IF_PASS POSITIVE>
416 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
422 .*---------------------------------------------------------------------*
423 :h3.TTCN-3::ParameterizationNotAllowed->Control part: timer
424 .*---------------------------------------------------------------------*
426 <TC - TTCN-3::ParameterizationNotAllowed->Control part: timer>
430 <MODULE TTCN ModuleA ModuleA.ttcn>
432 function MyFunc( timer t ) {}
439 <RESULT IF_PASS COUNT 1>
440 (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters
442 <RESULT IF_PASS COUNT 1>
445 <RESULT IF_PASS POSITIVE>
446 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
452 .*---------------------------------------------------------------------*
453 :h3.TTCN-3::ParameterizationNotAllowed->Component type--Function: timer
454 .*---------------------------------------------------------------------*
456 <TC - TTCN-3::ParameterizationNotAllowed->Component type--Function: timer>
460 <MODULE TTCN ModuleA ModuleA.ttcn>
462 function MyFunc( timer t ) {}
463 type component MyCT {
466 function MyCompFunc() runs on MyCT {
471 <RESULT IF_PASS COUNT 1>
472 (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters
474 <RESULT IF_PASS COUNT 1>
477 <RESULT IF_PASS POSITIVE>
478 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
484 .*---------------------------------------------------------------------*
485 :h3.TTCN-3::ParameterizationNotAllowed->Component type--Altstep: timer
486 .*---------------------------------------------------------------------*
488 <TC - TTCN-3::ParameterizationNotAllowed->Component type--Altstep: timer>
492 <MODULE TTCN ModuleA ModuleA.ttcn>
494 function MyFunc( timer t ) {}
495 type component MyCT {
498 altstep MyCompAltstep() runs on MyCT {
499 [else] { MyFunc(T(0)); };
503 <RESULT IF_PASS COUNT 1>
504 (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters
506 <RESULT IF_PASS COUNT 1>
509 <RESULT IF_PASS POSITIVE>
510 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
516 .*---------------------------------------------------------------------*
517 :h3.TTCN-3::ParameterizationNotAllowed->Component type--Testcase: timer
518 .*---------------------------------------------------------------------*
520 <TC - TTCN-3::ParameterizationNotAllowed->Component type--Testcase: timer>
524 <MODULE TTCN ModuleA ModuleA.ttcn>
526 function MyFunc( timer t ) {}
527 type component MyCT {
530 testcase MyTestcase() runs on MyCT {
535 <RESULT IF_PASS COUNT 1>
536 (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters
538 <RESULT IF_PASS COUNT 1>
541 <RESULT IF_PASS POSITIVE>
542 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
548 .*---------------------------------------------------------------------*
549 :h3.TTCN-3::ParameterizationNotAllowed->Function: timer
550 .*---------------------------------------------------------------------*
552 <TC - TTCN-3::ParameterizationNotAllowed->Function: timer>
556 <MODULE TTCN ModuleA ModuleA.ttcn>
558 function MyFunc_1( timer t ) {}
559 function MyFunc_2() {
565 <RESULT IF_PASS COUNT 1>
566 (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters
568 <RESULT IF_PASS COUNT 1>
571 <RESULT IF_PASS POSITIVE>
572 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
578 .*---------------------------------------------------------------------*
579 :h3.TTCN-3::ParameterizationNotAllowed->Altstep: timer
580 .*---------------------------------------------------------------------*
582 <TC - TTCN-3::ParameterizationNotAllowed->Altstep: timer>
586 <MODULE TTCN ModuleA ModuleA.ttcn>
588 function MyFunc( timer t ) {}
589 altstep MyAltstep(timer T) {
590 [else] { MyFunc(T(0)); };
594 <RESULT IF_PASS COUNT 1>
595 (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters
597 <RESULT IF_PASS COUNT 1>
600 <RESULT IF_PASS POSITIVE>
601 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
608 .*---------------------------------------------------------------------*
609 :h2.Not allowed type in a formal/actual parameter list
610 .*---------------------------------------------------------------------*
611 This test case group covers the requirement SA-4/2.
613 :nl. Some specific types are not allowed to be used in the parameter list
614 of a language element.
616 :li d='modulepar:' template, component type, port type, default and timer
617 are not allowed according to the TTCN-3 specification
618 :nl. ( NotAllowedTypeInParameterList->Modulepar )
619 :nl. NOTE: the component type and default are supported in the
620 implementation and not allowed the empty parameter list;
621 :li d='type:' any type is not currently supported in the implementation
622 :nl. ( NotAllowedTypeInParameterList->Type )
623 :nl. NOTE: all basic types, all user-defined types and address
624 type are allowed according to the TTCN-3 specification;
625 :li d='template:' component type, port type, default and timer are not allowed
626 :nl. ( NotAllowedTypeInParameterList->Template )
627 :nl. NOTE: the component type and default are supported in the
629 :li d='testcase:' component type, port type, default and timer are not allowed
630 :nl. ( NotAllowedTypeInParameterList->Testcase )
631 :nl. NOTE: the component type and default are supported in the
633 :li d='signature:' template, port type, default and timer are not allowed
634 :nl. ( NotAllowedTypeInParameterList->Signature );
637 :nl. We made a test for each type of values that is allowed to appear in the
638 formal/actual parameter lists of all language elements.
640 .*---------------------------------------------------------------------*
641 :h3.TTCN-3::NotAllowedTypeInParameterList->Modulepar: allowed types
642 .*---------------------------------------------------------------------*
644 <TC - TTCN-3::NotAllowedTypeInParameterList->Modulepar: allowed types>
648 <MODULE TTCN ModuleA ModuleA.ttcn>
650 type record MyRec { charstring field }
651 type record address { integer filed }
652 //modulepar not allowed types are tested : in TTCN3_SA_ttcn3adhoc.script (modulepar invalid simple type,
653 // modulepar invalid compound type, modulepar invalid list, modulepar invalid type: circular type definition)
655 boolean MyBool := false;
656 integer MyInt1, MyInt2;
658 address MyPC := { 23475 };
659 template integer MyTemp := 1;
663 <RESULT IF_PASS POSITIVE>
664 (?im)\bnotify\b.+?Generating.+?code
670 .*---------------------------------------------------------------------*
671 :h3.TTCN-3::NotAllowedTypeInParameterList->Modulepar: empty
672 .*---------------------------------------------------------------------*
674 <TC - TTCN-3::NotAllowedTypeInParameterList->Modulepar: empty>
678 <MODULE TTCN ModuleA ModuleA.ttcn>
683 <RESULT IF_PASS COUNT 1>
684 (?im)\berror\b.+?syntax.+?error
686 <RESULT IF_PASS COUNT 1>
693 .*---------------------------------------------------------------------*
694 :h3.TTCN-3::NotAllowedTypeInParameterList->Modulepar: port type
695 .*---------------------------------------------------------------------*
697 <TC - TTCN-3::NotAllowedTypeInParameterList->Modulepar: port type>
701 <MODULE TTCN ModuleA ModuleA.ttcn>
703 type port MyPort message { inout charstring; }
709 <RESULT IF_PASS COUNT 1>
710 (?im)\berror\b.+?module.+?parameter.+?cannot.+?port
712 <RESULT IF_PASS COUNT 1>
715 <RESULT IF_PASS POSITIVE>
716 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
722 .*---------------------------------------------------------------------*
723 :h3.TTCN-3::NotAllowedTypeInParameterList->Modulepar: timer
724 .*---------------------------------------------------------------------*
726 <TC - TTCN-3::NotAllowedTypeInParameterList->Modulepar: timer>
730 <MODULE TTCN ModuleA ModuleA.ttcn>
737 <RESULT IF_PASS COUNT 1>
738 (?im)\berror\b.+?syntax.+?error
740 <RESULT IF_PASS COUNT 1>
747 .*---------------------------------------------------------------------*
748 :h3.TTCN-3::NotAllowedTypeInParameterList->Types
749 .*---------------------------------------------------------------------*
751 <TC - TTCN-3::NotAllowedTypeInParameterList->Types>
755 <MODULE TTCN ModuleA ModuleA.ttcn>
757 type record rtype (integer p) {integer i (p .. p+10)}
759 const rtype(0.0) r1 := {i :=1}
760 const rtype('0'B) r2 := {i :=1}
761 const rtype('0'H) r3 := {i :=1}
762 const rtype('00'O) r4 := {i :=1}
763 const rtype("0") r5 := {i :=1}
765 type set stype (integer p) {integer i (p .. p+10)}
767 const stype(0.0) s1 := {i :=1}
768 const stype('0'B) s2 := {i :=1}
769 const stype('0'H) s3 := {i :=1}
770 const stype('00'O) s4 := {i :=1}
771 const stype("0") s5 := {i :=1}
774 <RESULT IF_FAIL COUNT POSITIVE>
775 (?im)\berror\b.+?not.+?supported
780 .*---------------------------------------------------------------------*
781 :h3.TTCN-3::NotAllowedTypeInParameterList->Template: allowed types
782 .*---------------------------------------------------------------------*
784 <TC - TTCN-3::NotAllowedTypeInParameterList->Template: allowed types>
788 <MODULE TTCN ModuleA ModuleA.ttcn>
790 type component MyCT {}
793 boolean field2 optional
795 type record address { integer filed }
797 float field1 optional,
804 template MyRec MyTempE := {?,?,?,?,?,?} // empty parameter list
805 template MyRec MyTemp (
811 template float par_6 ) := {
821 <RESULT IF_PASS POSITIVE>
822 (?im)\bnotify\b.+?Generating.+?code
828 .*---------------------------------------------------------------------*
829 :h3.TTCN-3::NotAllowedTypeInParameterList->Template: port type
830 .*---------------------------------------------------------------------*
832 <TC - TTCN-3::NotAllowedTypeInParameterList->Template: port type>
836 <MODULE TTCN ModuleA ModuleA.ttcn>
838 type port MyPort message { inout charstring; }
841 boolean field2 optional
843 template MySet MyTemp ( MyPort par_1 ) := {
849 <RESULT IF_PASS COUNT 1>
850 (?im)\berror\b.+?template.+?cannot.+?have.+?port
852 <RESULT IF_PASS COUNT 1>
855 <RESULT IF_PASS POSITIVE>
856 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
862 .*---------------------------------------------------------------------*
863 :h3.TTCN-3::NotAllowedTypeInParameterList->Template: timer
864 .*---------------------------------------------------------------------*
866 <TC - TTCN-3::NotAllowedTypeInParameterList->Template: timer>
870 <MODULE TTCN ModuleA ModuleA.ttcn>
874 boolean field2 optional
876 template MySet MyTemp ( timer par_1 ) := {
882 <RESULT IF_PASS COUNT 1>
883 (?im)\berror\b.+?syntax.+?error
885 <RESULT IF_PASS COUNT 1>
892 .*---------------------------------------------------------------------*
893 :h3.TTCN-3::NotAllowedTypeInParameterList->Function: allowed types
894 .*---------------------------------------------------------------------*
896 <TC - TTCN-3::NotAllowedTypeInParameterList->Function: allowed types>
900 <MODULE TTCN ModuleA ModuleA.ttcn>
902 type port MyPort message { inout charstring; }
903 type component MyCT {}
906 boolean field2 optional
908 type record address { integer filed }
909 function MyFuncE() {} // empty parameter list
914 template MySet par_4,
919 function MyCompFuncE() {} // empty parameter list
920 function MyCompFunc (
924 template MySet par_4,
928 timer par_8 ) runs on MyCT {}
929 external function MyExtFuncE(); // empty parameter list
930 external function MyExtFunc (
934 template MySet par_4,
941 <RESULT IF_PASS POSITIVE>
942 (?im)\bnotify\b.+?Generating.+?code
948 .*---------------------------------------------------------------------*
949 :h3.TTCN-3::NotAllowedTypeInParameterList->Altstep: allowed types
950 .*---------------------------------------------------------------------*
952 <TC - TTCN-3::NotAllowedTypeInParameterList->Altstep: allowed types>
956 <MODULE TTCN ModuleA ModuleA.ttcn>
958 type port MyPort message { inout charstring; }
959 type component MyCT {}
962 boolean field2 optional
964 type record address { integer filed }
965 altstep MyAltstepE() { [else]{} } // empty parameter list
970 template MySet par_4,
977 altstep MyCompAltstepE() { [else]{} } // empty parameter list
978 altstep MyCompAltstep (
982 template MySet par_4,
986 timer par_8 ) runs on MyCT {
991 <RESULT IF_PASS POSITIVE>
992 (?im)\bnotify\b.+?Generating.+?code
998 .*---------------------------------------------------------------------*
999 :h3.TTCN-3::NotAllowedTypeInParameterList->Testcase: allowed types
1000 .*---------------------------------------------------------------------*
1002 <TC - TTCN-3::NotAllowedTypeInParameterList->Testcase: allowed types>
1006 <MODULE TTCN ModuleA ModuleA.ttcn>
1008 type component MyCT {}
1011 boolean field2 optional
1013 type record address { integer filed }
1014 testcase MyTestcaseE() runs on MyCT {} // empty parameter list
1015 testcase MyTestcase (
1019 template MySet par_4,
1021 default par_6 ) runs on MyCT {}
1024 <RESULT IF_PASS POSITIVE>
1025 (?im)\bnotify\b.+?Generating.+?code
1031 .*---------------------------------------------------------------------*
1032 :h3.TTCN-3::NotAllowedTypeInParameterList->Testcase: port type
1033 .*---------------------------------------------------------------------*
1035 <TC - TTCN-3::NotAllowedTypeInParameterList->Testcase: port type>
1039 <MODULE TTCN ModuleA ModuleA.ttcn>
1041 type port MyPort message { inout charstring; }
1042 type component MyCT {}
1043 testcase MyTestcase( MyPort par_1 ) runs on MyCT {}
1046 <RESULT IF_PASS COUNT 1>
1047 (?im)\berror\b.+?testcase.+?cannot.+?have.+?port
1049 <RESULT IF_PASS COUNT 1>
1052 <RESULT IF_PASS POSITIVE>
1053 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1059 .*---------------------------------------------------------------------*
1060 :h3.TTCN-3::NotAllowedTypeInParameterList->Testcase: timer
1061 .*---------------------------------------------------------------------*
1063 <TC - TTCN-3::NotAllowedTypeInParameterList->Testcase: timer>
1067 <MODULE TTCN ModuleA ModuleA.ttcn>
1069 type component MyCT {}
1070 testcase MyTestcase( timer par_1 ) runs on MyCT {}
1073 <RESULT IF_PASS COUNT 1>
1074 (?im)\berror\b.+?syntax.+?error
1076 <RESULT IF_PASS COUNT 1>
1083 .*---------------------------------------------------------------------*
1084 :h3.TTCN-3::NotAllowedTypeInParameterList->Signature: allowed types
1085 .*---------------------------------------------------------------------*
1087 <TC - TTCN-3::NotAllowedTypeInParameterList->Signature: allowed types>
1091 <MODULE TTCN ModuleA ModuleA.ttcn>
1093 type component MyCT {}
1096 boolean field2 optional
1098 type record address { integer filed }
1099 signature MySigE(); // empty parameter list
1108 <RESULT IF_PASS POSITIVE>
1109 (?im)\bnotify\b.+?Generating.+?code
1115 .*---------------------------------------------------------------------*
1116 :h3.TTCN-3::NotAllowedTypeInParameterList->Signature: template
1117 .*---------------------------------------------------------------------*
1119 <TC - TTCN-3::NotAllowedTypeInParameterList->Signature: template>
1123 <MODULE TTCN ModuleA ModuleA.ttcn>
1125 signature MySig( template integer par_1 );
1128 <RESULT IF_PASS COUNT 1>
1129 (?im)\berror\b.+?syntax.+?error
1131 <RESULT IF_PASS COUNT 1>
1138 .*---------------------------------------------------------------------*
1139 :h3.TTCN-3::NotAllowedTypeInParameterList->Signature: port type
1140 .*---------------------------------------------------------------------*
1142 <TC - TTCN-3::NotAllowedTypeInParameterList->Signature: port type>
1146 <MODULE TTCN ModuleA ModuleA.ttcn>
1148 type port MyPort message { inout charstring; }
1149 signature MySig( MyPort par_1 );
1152 <RESULT IF_PASS COUNT 1>
1153 (?im)\berror\b.+?Port.+?cannot.+?be.+?signature
1155 <RESULT IF_PASS COUNT 1>
1158 <RESULT IF_PASS POSITIVE>
1159 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1165 .*---------------------------------------------------------------------*
1166 :h3.TTCN-3::NotAllowedTypeInParameterList->Signature: default
1167 .*---------------------------------------------------------------------*
1169 <TC - TTCN-3::NotAllowedTypeInParameterList->Signature: default>
1173 <MODULE TTCN ModuleA ModuleA.ttcn>
1175 signature MySig( default par_1 );
1178 <RESULT IF_PASS COUNT 1>
1179 (?im)\berror\b.+?Default.+?cannot.+?be.+?signature
1181 <RESULT IF_PASS COUNT 1>
1188 .*---------------------------------------------------------------------*
1189 :h3.TTCN-3::NotAllowedTypeInParameterList->Signature: timer
1190 .*---------------------------------------------------------------------*
1192 <TC - TTCN-3::NotAllowedTypeInParameterList->Signature: timer>
1196 <MODULE TTCN ModuleA ModuleA.ttcn>
1198 signature MySig( timer par_1 );
1201 <RESULT IF_PASS COUNT 1>
1202 (?im)\berror\b.+?syntax.+?error
1204 <RESULT IF_PASS COUNT 1>
1212 .*---------------------------------------------------------------------*
1213 :h2.Mismatch in actual and formal parameter list
1214 .*---------------------------------------------------------------------*
1215 This test case group covers the requirement SA-4/3.
1217 :nl. SA shall detect if there is a mismatch between the formal and the actual
1219 :p. - We can use the formal and the actual parameter list according to
1220 the TTCN-3 specification on the following language elements:
1221 :nl. type, template, function, altstep, testcase and signature.
1222 :nl. NOTE: types are not currently supported in the implementation.
1223 :p. - In the actual and the corresponding formal parameter list:
1225 :li d='number:'. shall be the same as the number of elements;
1226 :li d='order:'. shall be the same as the order of elements;
1227 :li d='types:'. shall be compatible with the types of elements.
1232 :li d='number:'. we made a test for each language elements;
1233 :li d='order and type compatibility:'. the type compatibility checking covers
1234 the order checking, therefore the order checking is not necessary
1235 (see the type compatibility checking in the requirement SA-5/2);
1238 .*---------------------------------------------------------------------*
1239 :h3.TTCN-3::MismachActualFormalParameterList->Types: number
1240 .*---------------------------------------------------------------------*
1242 <TC - TTCN-3::MismachActualFormalParameterList->Types: number>
1246 <MODULE TTCN ModuleA ModuleA.ttcn>
1248 type record rtype (integer p, boolean b) {integer i (p .. p+10), boolean b (b)}
1250 const rtype() r1 := {1, true}
1251 const rtype(1) r2 := {1, true}
1252 const rtype(1, true, 2) r3 := {1, true}
1254 type set stype (integer p, boolean b) {integer i (p .. p+10), boolean b (b)}
1256 const stype() s1 := {1, true}
1257 const stype(1) s2 := {1, true}
1258 const stype(1, true, 2) s3 := {1, true}
1262 <RESULT IF_FAIL POSITIVE>
1263 (?im)\berror\b.+?not.+?supported
1268 .*---------------------------------------------------------------------*
1269 :h3.TTCN-3::MismachActualFormalParameterList->Template: number
1270 .*---------------------------------------------------------------------*
1272 <TC - TTCN-3::MismachActualFormalParameterList->Template: number>
1276 <MODULE TTCN ModuleA ModuleA.ttcn>
1283 template MyRec MyTemp( charstring par_1, boolean par_2, integer par_3 ) := {
1288 template MyRec MyTemp2( charstring par_1 := "r", boolean par_2):=
1294 template MyRec MyTemp3(charstring par_1 := "r", boolean par_2:= false, integer par_3:=6):=
1300 function MyFunc( template MyRec mytemp ) {}
1302 MyFunc(MyTemp("r",true,6)); // good
1303 MyFunc(MyTemp("r",true)); // too few parameters
1304 MyFunc(MyTemp("r",true,6,1.3)); // too many parameters
1305 MyFunc(MyTemp2(true)); // too few parameters
1306 MyFunc(MyTemp3("r",true,6,1.3)); // too many parameters
1307 MyFunc(MyTemp3(-,true,6,1.3)); // too many parameters
1308 MyFunc(MyTemp3("r",true,6,-)); // too many parameters
1312 <RESULT IF_PASS COUNT 2>
1313 (?im)\berror\b.+?Too.+?few.+?parameters
1315 <RESULT IF_PASS COUNT 4>
1316 (?im)\berror\b.+?Too.+?many.+?parameters
1318 <RESULT IF_PASS COUNT 7>
1321 <RESULT IF_PASS POSITIVE>
1322 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1328 .*---------------------------------------------------------------------*
1329 :h3.TTCN-3::MismachActualFormalParameterList->Function: number
1330 .*---------------------------------------------------------------------*
1332 <TC - TTCN-3::MismachActualFormalParameterList->Function: number>
1336 <MODULE TTCN ModuleA ModuleA.ttcn>
1338 function MyFunc( integer par_1, charstring par_2, boolean par_3 ) {}
1339 function MyFunc2( integer par_1 := 6, charstring par_2){}
1340 function MyFunc3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false){}
1342 MyFunc(6,"r",true); // good
1343 MyFunc(6,"r"); // too few parameters
1344 MyFunc(56,"r",true,1.3); // too many parameters
1345 MyFunc2("r"); // too few parameters
1346 MyFunc3(6,"r",true,1.3); // too many parameters
1347 MyFunc3(-,"r",true,1.3); // too many parameters
1348 MyFunc3(6,"r",true,-); // too many parameters
1352 <RESULT IF_PASS COUNT 2>
1353 (?im)\berror\b.+?Too.+?few.+?parameters
1355 <RESULT IF_PASS COUNT 4>
1356 (?im)\berror\b.+?Too.+?many.+?parameters
1358 <RESULT IF_PASS COUNT 7>
1361 <RESULT IF_PASS POSITIVE>
1362 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1368 .*---------------------------------------------------------------------*
1369 :h3.TTCN-3::MismachActualFormalParameterList->Function_runs_on: number
1370 .*---------------------------------------------------------------------*
1372 <TC - TTCN-3::MismachActualFormalParameterList->Function_runs_on: number>
1376 <MODULE TTCN ModuleA ModuleA.ttcn>
1378 type component MyCT {}
1379 function MyFunc( integer par_1, charstring par_2, boolean par_3 ) runs on MyCT {}
1380 function MyFunc2( integer par_1 := 6, charstring par_2) runs on MyCT {}
1381 function MyFunc3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false) runs on MyCT {}
1382 testcase MyTemp() runs on MyCT {
1383 MyFunc(6,"r",true); // good
1384 MyFunc(6,"r"); // too few parameters
1385 MyFunc(56,"r",true,1.3); // too many parameters
1386 MyFunc2("r"); // too few parameters
1387 MyFunc3(6,"r",true,1.3); // too many parameters
1388 MyFunc3(-,"r",true,1.3); // too many parameters
1389 MyFunc3(6,"r",true,-); // too many parameters
1393 <RESULT IF_PASS COUNT 2>
1394 (?im)\berror\b.+?Too.+?few.+?parameters
1396 <RESULT IF_PASS COUNT 4>
1397 (?im)\berror\b.+?Too.+?many.+?parameters
1399 <RESULT IF_PASS COUNT 7>
1402 <RESULT IF_PASS POSITIVE>
1403 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1409 .*---------------------------------------------------------------------*
1410 :h3.TTCN-3::MismachActualFormalParameterList->External Function: number
1411 .*---------------------------------------------------------------------*
1413 <TC - TTCN-3::MismachActualFormalParameterList->External Function: number>
1417 <MODULE TTCN ModuleA ModuleA.ttcn>
1419 type component MyCT {}
1420 external function MyExtFunc( integer par_1, charstring par_2, boolean par_3 );
1421 external function MyExtFunc2( integer par_1 := 6, charstring par_2);
1422 external function MyExtFunc3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false);
1424 MyExtFunc(6,"r",true); // good
1425 MyExtFunc(6,"r"); // too few parameters
1426 MyExtFunc(56,"r",true,1.3); // too many parameters
1427 MyExtFunc2("r"); // too few parameters
1428 MyExtFunc3(6,"r",true,1.3); // too many parameters
1429 MyExtFunc3(-,"r",true,1.3); // too many parameters
1430 MyExtFunc3(6,"r",true,-); // too many parameters
1434 <RESULT IF_PASS COUNT 2>
1435 (?im)\berror\b.+?Too.+?few.+?parameters
1437 <RESULT IF_PASS COUNT 4>
1438 (?im)\berror\b.+?Too.+?many.+?parameters
1440 <RESULT IF_PASS COUNT 7>
1443 <RESULT IF_PASS POSITIVE>
1444 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1450 .*---------------------------------------------------------------------*
1451 :h3.TTCN-3::MismachActualFormalParameterList->Altstep: number
1452 .*---------------------------------------------------------------------*
1454 <TC - TTCN-3::MismachActualFormalParameterList->Altstep: number>
1458 <MODULE TTCN ModuleA ModuleA.ttcn>
1460 altstep MyAltstep( integer par_1, charstring par_2, boolean par_3 ) {
1463 altstep MyAltstep2( integer par_1 := 6, charstring par_2) {
1466 altstep MyAltstep3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false) {
1470 MyAltstep(6,"r",true); // good
1471 MyAltstep(6,"r"); // too few parameters
1472 MyAltstep(56,"r",true,1.3); // too many parameters
1473 MyAltstep2("r"); // too few parameters
1474 MyAltstep3(6,"r",true,1.3); // too many parameters
1475 MyAltstep3(-,"r",true,1.3); // too many parameters
1476 MyAltstep3(6,"r",true,-); // too many parameters
1480 <RESULT IF_PASS COUNT 2>
1481 (?im)\berror\b.+?Too.+?few.+?parameters
1483 <RESULT IF_PASS COUNT 4>
1484 (?im)\berror\b.+?Too.+?many.+?parameters
1486 <RESULT IF_PASS COUNT 7>
1489 <RESULT IF_PASS POSITIVE>
1490 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1496 .*---------------------------------------------------------------------*
1497 :h3.TTCN-3::MismachActualFormalParameterList->Altstep_runs_on: number
1498 .*---------------------------------------------------------------------*
1500 <TC - TTCN-3::MismachActualFormalParameterList->Altstep_runs_on: number>
1504 <MODULE TTCN ModuleA ModuleA.ttcn>
1506 type component MyCT {}
1507 altstep MyAltstep( integer par_1, charstring par_2, boolean par_3 ) runs on MyCT {
1510 altstep MyAltstep2( integer par_1 := 6, charstring par_2) runs on MyCT {
1513 altstep MyAltstep3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false) runs on MyCT {
1516 testcase MyTemp() runs on MyCT {
1517 MyAltstep(6,"r",true); // good
1518 MyAltstep(6,"r"); // too few parameters
1519 MyAltstep(56,"r",true,1.3); // too many parameters
1520 MyAltstep2("r"); // too few parameters
1521 MyAltstep3(6,"r",true,1.3); // too many parameters
1522 MyAltstep3(-,"r",true,1.3); // too many parameters
1523 MyAltstep3(6,"r",true,-); // too many parameters
1527 <RESULT IF_PASS COUNT 2>
1528 (?im)\berror\b.+?Too.+?few.+?parameters
1530 <RESULT IF_PASS COUNT 4>
1531 (?im)\berror\b.+?Too.+?many.+?parameters
1533 <RESULT IF_PASS COUNT 7>
1536 <RESULT IF_PASS POSITIVE>
1537 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1543 .*---------------------------------------------------------------------*
1544 :h3.TTCN-3::MismachActualFormalParameterList->Testcase: numberr
1545 .*---------------------------------------------------------------------*
1547 <TC - TTCN-3::MismachActualFormalParameterList->Testcase: number>
1551 <MODULE TTCN ModuleA ModuleA.ttcn>
1553 type component MyCT {}
1554 testcase MyTestcase( integer par_1, charstring par_2, boolean par_3 ) runs on MyCT {}
1555 testcase MyTestcase2( integer par_1 := 6, charstring par_2) runs on MyCT {}
1556 testcase MyTestcase3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false) runs on MyCT {}
1558 execute ( MyTestcase(6,"r",true) ); // good
1559 execute ( MyTestcase(6,"r") ); // too few parameters
1560 execute ( MyTestcase(56,"r",true,1.3) ); // too many parameters
1561 execute ( MyTestcase2("r") ); // too few parameters
1562 execute ( MyTestcase3(6,"r",true,1.3) ); // too many parameters
1563 execute ( MyTestcase3(-,"r",true,1.3) ); // too many parameters
1564 execute ( MyTestcase3(6,"r",true,-) ); // too many parameters
1568 <RESULT IF_PASS COUNT 2>
1569 (?im)\berror\b.+?Too.+?few.+?parameters
1571 <RESULT IF_PASS COUNT 4>
1572 (?im)\berror\b.+?Too.+?many.+?parameters
1574 <RESULT IF_PASS COUNT 7>
1577 <RESULT IF_PASS POSITIVE>
1578 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1584 .*---------------------------------------------------------------------*
1585 :h3.TTCN-3::MismachActualFormalParameterList->Signature: number
1586 .*---------------------------------------------------------------------*
1588 <TC - TTCN-3::MismachActualFormalParameterList->Signature: number>
1592 <MODULE TTCN ModuleA ModuleA.ttcn>
1594 signature MySig( integer par_1, charstring par_2, boolean par_3 );
1595 type port MyPortType procedure { inout MySig }
1596 type component MyComp {
1597 port MyPortType MyPort;
1599 function MyFunc() runs on MyComp {
1600 MyPort.call(MySig:{ 6,"r",true }, 20E-3 + 20E-3) {
1601 [] MyPort.getreply {}
1603 MyPort.call(MySig:{ 6,"r" }, 20E-3 + 20E-3) {
1604 [] MyPort.getreply {}
1606 MyPort.call(MySig:{ 6,"r",true,6.8 }, 20E-3 + 20E-3) {
1607 [] MyPort.getreply {}
1612 <RESULT IF_PASS COUNT 1>
1613 (?im)\berror\b.+?Too.+?few.+?elements.+?MySig
1615 <RESULT IF_PASS COUNT 1>
1616 (?im)\berror\b.+?Too.+?many.+?elements.+?MySig
1618 <RESULT IF_PASS COUNT 2>
1621 <RESULT IF_PASS POSITIVE>
1622 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1629 .*---------------------------------------------------------------------*
1630 :h2.Parameter list of a modified template
1631 .*---------------------------------------------------------------------*
1632 This test case group covers the requirement SA-4/4.
1634 :nl. The followings apply:
1635 :nl. - the derived template shall not omit parameters defined at any of the
1636 modification steps between the base template and the actual modified
1638 :nl. - a derived template can have additional (appended) parameters if wished
1639 :nl. - base template fields containing parameterized templates shall not be
1640 modified or explicitly omitted in a modified template (including inline
1642 :nl. - base template field that depends on a parameter shall not be modified
1643 or explicitly omitted in a modified template (?)
1647 :p. TODO: <what TCs are missing and why>
1652 .*---------------------------------------------------------------------*
1653 :h2.Parameter is not allowed to be passed by value/reference
1654 .*---------------------------------------------------------------------*
1655 This test case group covers the requirement SA-4/5.
1657 :nl. Many language elements allow only parameter passing by value or reference.
1661 :li d='Basic types, basic string types, user-defined structured types, address type and component type:'.
1662 By default, all actual parameters of these types are passed by value.
1663 :nl.This may otionally be denoted by the keyword "in".
1664 :nl.To pass parameters of these types by reference the keywords "out" or "inout"
1666 :nl.NOTE: the behaviour of the "default" type is similar to the listed below
1667 in the implementation.
1668 :li d='Timers and ports:'. are always passed by reference.
1669 :nl.Timer parameter are identified by the keyword timer.
1670 :nl.Port parameter are identified by their port type.
1671 :nl.The keyword "inout" may optionally be used to denote passing by reference.
1673 :p. Parameters passed by reference:
1674 :nl.Passing parameters by reference has the following limitations:
1676 :li d='a)'. only the formal parameter lists to altsteps, functions, signatures
1677 and testcases may contain pass-by-reference parameters;
1678 :li d='b)'. the actual parameters shall only be variables, ports or timers.
1680 :p. Parameters passed by value:
1681 :nl.Actual parameters that are passed by value may be variables as well as
1682 constants, templates etc.
1685 :nl.The "component type" and the "default" are allowed in the modulepar, the
1686 template and the testcase in the implementation far afield from the TTCN-3
1688 :nl.The "out" and the "inout" parameters can be read and set from within e.g.
1689 the function. The difference is the "out" parameter may be unbound but the
1690 "inout" parameter must be initialized before called.
1693 :nl.There are some tests for the template, function, altstep, testcase and
1694 signature language elements where we can use "in","out" or "inout" parameters.
1695 First we checked the allowed cases (positive tests). Other tests are for each
1696 type of values that is allowed to appear in the formal/actual parameter
1697 lists of all language elements with "defaul in", "in", "out" and "inout"
1700 .*---------------------------------------------------------------------*
1701 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Template: allowed in
1702 .*---------------------------------------------------------------------*
1704 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Template: allowed in>
1708 <MODULE TTCN ModuleA ModuleA.ttcn>
1710 type component MyCT {}
1711 type record MyRecord {
1713 boolean field2 optional
1715 type record address { integer field }
1717 integer field11 optional,
1719 octetstring field21,
1720 octetstring field22,
1732 template MyRec MyTemp (
1733 integer par_11, // basic type
1735 octetstring par_21, // basic string type
1736 in octetstring par_22,
1737 MyRecord par_31, // user-defined structured type
1739 address par_41, // address
1741 template float par_51, // template
1742 in template float par_52,
1743 MyCT par_61, // component type
1745 default par_71, // default
1746 in default par_72 ) := {
1762 function MyFunc( template MyRec mytemp ) {}
1765 var octetstring myoctet;
1766 var MyRecord myrecord;
1769 var MyCT myct_1, myct_2;
1770 var default mydef_1, mydef_2;
1771 MyFunc(MyTemp( 1,myint, myoctet,'A5'O, myrecord,{6.7,true}, {5},myadd,
1772 mytemp,7.8, myct_1,myct_2, mydef_1,mydef_1));
1776 <RESULT IF_PASS POSITIVE>
1777 (?im)\bnotify\b.+?Generating.+?code
1783 .*---------------------------------------------------------------------*
1784 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Template: allowed non-mandatory in
1785 .*---------------------------------------------------------------------*
1787 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Template: allowed non-mandatory in>
1791 <MODULE TTCN ModuleA ModuleA.ttcn>
1793 type component MyCT {}
1794 type record MyRecord {
1796 boolean field2 optional
1798 type record address { integer field }
1800 integer field11 optional,
1802 octetstring field21,
1803 octetstring field22,
1815 template MyRec MyTemp (
1816 integer par_11 := 1, // basic type
1817 in integer par_12 := 1,
1818 octetstring par_21 := 'A5'O, // basic string type
1819 in octetstring par_22 := 'A5'O,
1820 MyRecord par_31 := {6.7,true},// user-defined structured type
1821 in MyRecord par_32 := {6.7,true},
1822 address par_41 := {5}, // address
1823 in address par_42 := {5},
1824 template float par_51 := 7.8, // template
1825 in template float par_52 := 7.8,
1826 MyCT par_61, // component type
1828 default par_71, // default
1829 in default par_72 ) := {
1845 function MyFunc( template MyRec mytemp ) {}
1848 var octetstring myoctet;
1849 var MyRecord myrecord;
1852 var MyCT myct_1, myct_2;
1853 var default mydef_1, mydef_2;
1854 MyFunc(MyTemp( 1,myint, myoctet,'A5'O, myrecord,{6.7,true}, {5},myadd,
1855 mytemp,7.8, myct_1,myct_2, mydef_1,mydef_1));
1859 <RESULT IF_PASS POSITIVE>
1860 (?im)\bnotify\b.+?Generating.+?code
1866 .*---------------------------------------------------------------------*
1867 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Template: out, inout
1868 .*---------------------------------------------------------------------*
1870 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Template: out, inout>
1874 <MODULE TTCN ModuleA ModuleA.ttcn>
1876 type component MyCT {}
1879 boolean field2 optional
1881 type record address { integer field }
1883 integer field1 optional,
1891 template MyRec MyTemp (
1892 out integer par_13_1, // basic type
1893 inout integer par_14_1,
1894 out octetstring par_13_2, // basic string type
1895 inout octetstring par_14_2,
1896 out MySet par_23, // user-defined structured type
1898 out address par_33, // address
1899 inout address par_34,
1900 out template float par_43, // template
1901 inout template float par_44,
1902 out MyCT par_53, // component type
1904 out default par_73, // default
1905 inout default par_74 ) := {
1916 <RESULT IF_PASS COUNT 14>
1917 (?im)\berror\b.+?template.+?cannot.+?have.+?out.+?parameter
1919 <RESULT IF_PASS COUNT 7>
1920 (?im)\berror\b.+?template.+?cannot.+?have.+?inout.+?parameter
1922 <RESULT IF_PASS COUNT 14>
1925 <RESULT IF_PASS POSITIVE>
1926 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1932 .*---------------------------------------------------------------------*
1933 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Template: non-mandatory out, inout
1934 .*---------------------------------------------------------------------*
1936 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Template: non-mandatory out, inout>
1940 <MODULE TTCN ModuleA ModuleA.ttcn>
1942 type component MyCT {}
1945 boolean field2 optional
1947 type record address { integer field }
1949 integer field1 optional,
1955 template MyRec MyTemp (
1956 out integer par_13_1 := 5, // basic type
1957 inout integer par_14_1 := 5,
1958 out octetstring par_13_2 := 'A5'O, // basic string type
1959 inout octetstring par_14_2 := 'A5'O,
1960 out MySet par_23 := {field1:=1.0,field2:=true}, // user-defined structured type
1961 inout MySet par_24 := {field1:=1.0,field2:=true},
1962 out address par_33 := {5}, // address
1963 inout address par_34 := {5},
1964 out template float par_43 := 7.8, // template
1965 inout template float par_44 := 7.8) := {
1974 <RESULT IF_PASS COUNT 10>
1975 (?im)\berror\b.+?template.+?cannot.+?have.+?out.+?parameter
1977 <RESULT IF_PASS COUNT 5>
1978 (?im)\berror\b.+?template.+?cannot.+?have.+?inout.+?parameter
1980 <RESULT IF_PASS COUNT 8>
1981 (?im)\berror\b.+?reference.+?variable.+?value.+?parameter.+?expected
1983 <RESULT IF_PASS COUNT 20>
1986 <RESULT IF_PASS POSITIVE>
1987 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
1993 .*---------------------------------------------------------------------*
1994 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: allowed in/out/inout
1995 .*---------------------------------------------------------------------*
1997 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: allowed in/out/inout>
2001 <MODULE TTCN ModuleA ModuleA.ttcn>
2003 type port MyPort message { inout charstring; }
2004 type component MyCT {}
2007 boolean field2 optional
2009 type record address { integer field }
2011 integer par_11_1, // basic type
2012 in integer par_12_1,
2013 out integer par_13_1,
2014 inout integer par_14_1,
2016 octetstring par_11_2, // basic string type
2017 in octetstring par_12_2,
2018 out octetstring par_13_2,
2019 inout octetstring par_14_2,
2021 MySet par_21, // user-defined structured type
2026 address par_31, // address
2029 inout address par_34,
2031 template MySet par_41, // template
2032 in template MySet par_42,
2033 out template MySet par_43,
2034 inout template MySet par_44,
2036 MyCT par_51, // component type
2041 MyPort par_61, // port type
2042 inout MyPort par_64,
2044 default par_71, // default
2047 inout default par_74,
2049 timer par_81, // timer
2050 inout timer par_84 ) {}
2053 <RESULT IF_PASS POSITIVE>
2054 (?im)\bnotify\b.+?Generating.+?code
2060 .*---------------------------------------------------------------------*
2061 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: allowed in/out/inout
2062 .*---------------------------------------------------------------------*
2064 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: allowed in/out/inout>
2068 <MODULE TTCN ModuleA ModuleA.ttcn>
2070 type port MyPort message { inout charstring; }
2071 type component MyCT {}
2074 boolean field2 optional
2076 type record address { integer field }
2077 function MyCompFunc (
2078 integer par_11_1, // basic type
2079 in integer par_12_1,
2080 out integer par_13_1,
2081 inout integer par_14_1,
2083 octetstring par_11_2, // basic string type
2084 in octetstring par_12_2,
2085 out octetstring par_13_2,
2086 inout octetstring par_14_2,
2088 MySet par_21, // user-defined structured type
2093 address par_31, // address
2096 inout address par_34,
2098 template MySet par_41, // template
2099 in template MySet par_42,
2100 out template MySet par_43,
2101 inout template MySet par_44,
2103 MyCT par_51, // component type
2108 MyPort par_61, // port type
2109 inout MyPort par_64,
2111 default par_71, // default
2114 inout default par_74,
2116 timer par_81, // timer
2117 inout timer par_84 ) runs on MyCT {}
2120 <RESULT IF_PASS POSITIVE>
2121 (?im)\bnotify\b.+?Generating.+?code
2127 .*---------------------------------------------------------------------*
2128 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: allowed non-mandatory in/out/inout
2129 .*---------------------------------------------------------------------*
2131 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: allowed non-mandatory in/out/inout>
2135 <MODULE TTCN ModuleA ModuleA.ttcn>
2137 type port MyPort message { inout charstring; }
2140 boolean field2 optional
2142 type record address { integer field }
2143 type component MyCT {
2144 const integer comp_const_i := 0;
2145 var integer comp_var_i := 0;
2146 const octetstring comp_const_o := '00'O;
2147 var octetstring comp_var_o := '00'O;
2148 const MySet comp_const_set := {field1 := 1.0, field2 := true};
2149 var MySet comp_var_set := {field1 := 1.0, field2 := true};
2150 const address comp_const_address := {5};
2151 var address comp_var_address := {5};
2152 port MyPort comp_port;
2153 timer comp_timer := 1.0;
2155 function MyCompFunc (
2156 integer par_11_1 := comp_const_i, // basic type
2157 in integer par_12_1 := comp_const_i,
2158 out integer par_13_1 := comp_var_i,
2159 inout integer par_14_1 := comp_var_i,
2161 octetstring par_11_2 := comp_const_o, // basic string type
2162 in octetstring par_12_2 := comp_const_o,
2163 out octetstring par_13_2 := comp_var_o,
2164 inout octetstring par_14_2 := comp_var_o,
2166 MySet par_21 := comp_const_set, // user-defined structured type
2167 in MySet par_22 := comp_const_set,
2168 out MySet par_23 := comp_var_set,
2169 inout MySet par_24 := comp_var_set,
2171 address par_31 := comp_const_address, // address
2172 in address par_32 := comp_const_address,
2173 out address par_33 := comp_var_address,
2174 inout address par_34 := comp_var_address,
2176 MyPort par_61 := comp_port, // port type
2177 inout MyPort par_64 := comp_port,
2179 timer par_81 := comp_timer, // timer
2180 inout timer par_84 := comp_timer ) runs on MyCT {}
2183 <RESULT IF_PASS POSITIVE>
2184 (?im)\bnotify\b.+?Generating.+?code
2191 .*---------------------------------------------------------------------*
2192 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: allowed in/out/inout
2193 .*---------------------------------------------------------------------*
2195 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: allowed in/out/inout>
2199 <MODULE TTCN ModuleA ModuleA.ttcn>
2201 type port MyPort message { inout charstring; }
2202 type component MyCT {}
2205 boolean field2 optional
2207 type record address { integer field }
2208 external function MyExtFunc (
2209 integer par_11_1, // basic type
2210 in integer par_12_1,
2211 out integer par_13_1,
2212 inout integer par_14_1,
2214 octetstring par_11_2, // basic string type
2215 in octetstring par_12_2,
2216 out octetstring par_13_2,
2217 inout octetstring par_14_2,
2219 MySet par_21, // user-defined structured type
2224 address par_31, // address
2227 inout address par_34,
2229 template MySet par_41, // template
2230 in template MySet par_42,
2231 out template MySet par_43,
2232 inout template MySet par_44,
2234 MyCT par_51, // component type
2239 MyPort par_61, // port type
2240 inout MyPort par_64,
2242 default par_71, // default
2245 inout default par_74,
2247 timer par_81, // timer
2248 inout timer par_84 );
2251 <RESULT IF_PASS POSITIVE>
2252 (?im)\bnotify\b.+?Generating.+?code
2258 .*---------------------------------------------------------------------*
2259 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: port type with in/out
2260 .*---------------------------------------------------------------------*
2262 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: port type with in/out>
2266 <MODULE TTCN ModuleA ModuleA.ttcn>
2268 type port MyPort message { inout charstring; }
2269 type component MyCT {}
2270 function MyFunc ( in MyPort par_1, out MyPort par_2 ) {}
2271 function MyCompFunc ( in MyPort par_1, out MyPort par_2 ) {}
2272 external function MyExtFunc ( in MyPort par_1, out MyPort par_2 );
2275 <RESULT IF_PASS COUNT 6>
2276 (?im)\berror\b.+?Port.+?cannot.+?used.+?value
2278 <RESULT IF_PASS COUNT 3>
2279 (?im)\berror\b.+?Port.+?cannot.+?used.+?out.+?value
2281 <RESULT IF_PASS COUNT 6>
2284 <RESULT IF_PASS POSITIVE>
2285 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2291 .*---------------------------------------------------------------------*
2292 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: timer with in/out
2293 .*---------------------------------------------------------------------*
2295 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: timer with in/out>
2299 <MODULE TTCN ModuleA ModuleA.ttcn>
2301 type component MyCT {}
2302 function MyFunc ( in timer par_1, out timer par_2 ) {}
2303 function MyCompFunc ( in timer par_1, out timer par_2 ) {}
2304 external function MyExtFunc ( in timer par_1, out timer par_2 );
2307 <RESULT IF_PASS COUNT 6>
2308 (?im)\berror\b.+?syntax.+?error
2310 <RESULT IF_PASS COUNT 6>
2317 .*---------------------------------------------------------------------*
2318 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: basic type
2319 .*---------------------------------------------------------------------*
2321 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: basic type>
2325 <MODULE TTCN ModuleA ModuleA.ttcn>
2328 integer par_1, // basic type
2331 inout integer par_4 ) {
2332 var integer temp := par_1;
2339 var integer var_1 := 1;
2340 var integer var_2 := 2;
2341 var integer var_3 := 3;
2342 var integer var_4 := 4;
2343 var integer var_11, var_22, var_33, var_44;
2344 MyFunc( var_1, var_2, var_3, var_4); // good
2345 MyFunc( var_11, var_22, var_33, var_44); // good
2346 MyFunc( 1, 2, var_3, var_4); // good
2347 MyFunc( 1, 2, 3, 4); // error
2351 <RESULT IF_PASS COUNT 2>
2352 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2354 <RESULT IF_PASS COUNT 1>
2355 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2357 <RESULT IF_PASS COUNT 2>
2360 <RESULT IF_PASS POSITIVE>
2361 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2367 .*---------------------------------------------------------------------*
2368 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: basic type as non-mandatory parameter
2369 .*---------------------------------------------------------------------*
2371 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: basic type as non-mandatory parameter>
2375 <MODULE TTCN ModuleA ModuleA.ttcn>
2378 integer par_1 := 1, // basic type
2379 in integer par_2 := 1,
2380 out integer par_3 := 1,
2381 inout integer par_4 := 1 ) {
2385 <RESULT IF_PASS COUNT 2>
2386 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2388 <RESULT IF_PASS COUNT 1>
2389 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2391 <RESULT IF_PASS COUNT 2>
2394 <RESULT IF_PASS POSITIVE>
2395 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2401 .*---------------------------------------------------------------------*
2402 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: basic type
2403 .*---------------------------------------------------------------------*
2405 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: basic type>
2409 <MODULE TTCN ModuleA ModuleA.ttcn>
2411 type component MyCT {}
2412 function MyCompFunc (
2413 integer par_1, // basic type
2416 inout integer par_4 ) runs on MyCT {
2417 var integer temp := par_1;
2423 function MyTempFunc () runs on MyCT {
2424 var integer var_1 := 1;
2425 var integer var_2 := 2;
2426 var integer var_3 := 3;
2427 var integer var_4 := 4;
2428 var integer var_11, var_22, var_33, var_44;
2429 MyCompFunc( var_1, var_2, var_3, var_4); // good
2430 MyCompFunc( var_11, var_22, var_33, var_44); // good
2431 MyCompFunc( 1, 2, var_3, var_4); // good
2432 MyCompFunc( 1, 2, 3, 4); // error
2436 <RESULT IF_PASS COUNT 2>
2437 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2439 <RESULT IF_PASS COUNT 1>
2440 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2442 <RESULT IF_PASS COUNT 2>
2445 <RESULT IF_PASS POSITIVE>
2446 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2452 .*---------------------------------------------------------------------*
2453 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: basic type
2454 .*---------------------------------------------------------------------*
2456 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: basic type>
2460 <MODULE TTCN ModuleA ModuleA.ttcn>
2462 external function MyExtFunc (
2463 integer par_1, // basic type
2466 inout integer par_4 );
2468 var integer var_1 := 1;
2469 var integer var_2 := 2;
2470 var integer var_3 := 3;
2471 var integer var_4 := 4;
2472 var integer var_11, var_22, var_33, var_44;
2473 MyExtFunc( var_1, var_2, var_3, var_4); // good
2474 MyExtFunc( var_11, var_22, var_33, var_44); // good
2475 MyExtFunc( 1, 2, var_3, var_4); // good
2476 MyExtFunc( 1, 2, 3, 4); // error
2480 <RESULT IF_PASS COUNT 2>
2481 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2483 <RESULT IF_PASS COUNT 1>
2484 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2486 <RESULT IF_PASS COUNT 2>
2489 <RESULT IF_PASS POSITIVE>
2490 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2496 .*---------------------------------------------------------------------*
2497 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: basic type as non-mandatory parameter
2498 .*---------------------------------------------------------------------*
2500 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: basic type as non-mandatory parameter>
2504 <MODULE TTCN ModuleA ModuleA.ttcn>
2506 external function MyExtFunc (
2507 integer par_1 := 1, // basic type
2508 in integer par_2 := 1,
2509 out integer par_3 := 1,
2510 inout integer par_4 := 1 );
2513 <RESULT IF_PASS COUNT 2>
2514 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2516 <RESULT IF_PASS COUNT 1>
2517 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2519 <RESULT IF_PASS COUNT 2>
2522 <RESULT IF_PASS POSITIVE>
2523 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2529 .*---------------------------------------------------------------------*
2530 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: basic string type
2531 .*---------------------------------------------------------------------*
2533 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: basic string type>
2537 <MODULE TTCN ModuleA ModuleA.ttcn>
2540 charstring par_1, // basic string type
2541 in charstring par_2,
2542 out charstring par_3,
2543 inout charstring par_4 ) {
2544 var charstring temp := par_1;
2551 var charstring var_1 := "q";
2552 var charstring var_2 := "w";
2553 var charstring var_3 := "e";
2554 var charstring var_4 := "r";
2555 var charstring var_11, var_22, var_33, var_44;
2556 MyFunc( var_1, var_2, var_3, var_4); // good
2557 MyFunc( var_11, var_22, var_33, var_44); // good
2558 MyFunc( "w", "e", var_3, var_4); // good
2559 MyFunc( "q", "b", "5", "w"); // error
2563 <RESULT IF_PASS COUNT 2>
2564 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2566 <RESULT IF_PASS COUNT 1>
2567 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2569 <RESULT IF_PASS COUNT 2>
2572 <RESULT IF_PASS POSITIVE>
2573 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2579 .*---------------------------------------------------------------------*
2580 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: basic string type
2581 .*---------------------------------------------------------------------*
2583 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: basic string type>
2587 <MODULE TTCN ModuleA ModuleA.ttcn>
2589 type component MyCT {}
2590 function MyCompFunc (
2591 charstring par_1, // basic string type
2592 in charstring par_2,
2593 out charstring par_3,
2594 inout charstring par_4 ) runs on MyCT {
2595 var charstring temp := par_1;
2601 function MyTempFunc () runs on MyCT {
2602 var charstring var_1 := "q";
2603 var charstring var_2 := "w";
2604 var charstring var_3 := "e";
2605 var charstring var_4 := "r";
2606 var charstring var_11, var_22, var_33, var_44;
2607 MyCompFunc( var_1, var_2, var_3, var_4); // good
2608 MyCompFunc( var_11, var_22, var_33, var_44); // good
2609 MyCompFunc( "w", "e", var_3, var_4); // good
2610 MyCompFunc( "q", "b", "5", "w"); // error
2614 <RESULT IF_PASS COUNT 2>
2615 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2617 <RESULT IF_PASS COUNT 1>
2618 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2620 <RESULT IF_PASS COUNT 2>
2623 <RESULT IF_PASS POSITIVE>
2624 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2630 .*---------------------------------------------------------------------*
2631 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: basic string type
2632 .*---------------------------------------------------------------------*
2634 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: basic string type>
2638 <MODULE TTCN ModuleA ModuleA.ttcn>
2640 external function MyExtFunc (
2641 charstring par_1, // basic string type
2642 in charstring par_2,
2643 out charstring par_3,
2644 inout charstring par_4 );
2646 var charstring var_1 := "q";
2647 var charstring var_2 := "w";
2648 var charstring var_3 := "e";
2649 var charstring var_4 := "r";
2650 var charstring var_11, var_22, var_33, var_44;
2651 MyExtFunc( var_1, var_2, var_3, var_4); // good
2652 MyExtFunc( var_11, var_22, var_33, var_44); // good
2653 MyExtFunc( "w", "e", var_3, var_4); // good
2654 MyExtFunc( "q", "b", "5", "w"); // error
2658 <RESULT IF_PASS COUNT 2>
2659 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2661 <RESULT IF_PASS COUNT 1>
2662 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2664 <RESULT IF_PASS COUNT 2>
2667 <RESULT IF_PASS POSITIVE>
2668 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2674 .*---------------------------------------------------------------------*
2675 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: user-defined type
2676 .*---------------------------------------------------------------------*
2678 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: user-defined type>
2682 <MODULE TTCN ModuleA ModuleA.ttcn>
2686 boolean field2 optional
2689 MySet par_1, // user-defined type
2692 inout MySet par_4 ) {
2693 var MySet temp := { field1:=par_1.field1 }
2694 par_1.field1 := par_2.field1;
2695 par_2.field1 := par_3.field1;
2696 par_3.field1 := par_4.field1;
2697 par_4.field1 := temp.field1;
2700 var MySet var_1 := { field1:=1.3 };
2701 var MySet var_2 := { field1:=2.5 };
2702 var MySet var_3 := { field1:=3.1 };
2703 var MySet var_4 := { field1:=4.9 };
2704 var MySet var_11, var_22, var_33, var_44;
2705 MyFunc(var_1,var_2,var_3,var_4); // good
2706 MyFunc(var_11,var_22,var_33,var_44); // good
2707 MyFunc( {field1:=1.2, field2:=true}, // good
2708 {field1:=2.5, field2:=true},
2711 MyFunc( {field1:=1.2, field2:=true}, // error
2712 {field1:=2.5, field2:=true},
2713 {field1:=3.6, field2:=true},
2714 {field1:=4.1, field2:=true});
2718 <RESULT IF_PASS COUNT 2>
2719 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2721 <RESULT IF_PASS COUNT 1>
2722 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2724 <RESULT IF_PASS COUNT 2>
2727 <RESULT IF_PASS POSITIVE>
2728 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2734 .*---------------------------------------------------------------------*
2735 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: user-defined type
2736 .*---------------------------------------------------------------------*
2738 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: user-defined type>
2742 <MODULE TTCN ModuleA ModuleA.ttcn>
2744 type component MyCT {}
2747 boolean field2 optional
2749 function MyCompFunc (
2750 MySet par_1, // user-defined type
2753 inout MySet par_4 ) runs on MyCT {
2754 var MySet temp := { field1:=par_1.field1 }
2755 par_1.field1 := par_2.field1;
2756 par_2.field1 := par_3.field1;
2757 par_3.field1 := par_4.field1;
2758 par_4.field1 := temp.field1;
2760 function MyTempFunc () runs on MyCT {
2761 var MySet var_1 := { field1:=1.3 };
2762 var MySet var_2 := { field1:=2.5 };
2763 var MySet var_3 := { field1:=3.1 };
2764 var MySet var_4 := { field1:=4.9 };
2765 var MySet var_11, var_22, var_33, var_44;
2766 MyCompFunc(var_1,var_2,var_3,var_4); // good
2767 MyCompFunc(var_11,var_22,var_33,var_44); // good
2768 MyCompFunc( {field1:=1.2, field2:=true}, // good
2769 {field1:=2.5, field2:=true},
2772 MyCompFunc( {field1:=1.2, field2:=true}, // error
2773 {field1:=2.5, field2:=true},
2774 {field1:=3.6, field2:=true},
2775 {field1:=4.1, field2:=true});
2779 <RESULT IF_PASS COUNT 2>
2780 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2782 <RESULT IF_PASS COUNT 1>
2783 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2785 <RESULT IF_PASS COUNT 2>
2788 <RESULT IF_PASS POSITIVE>
2789 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2795 .*---------------------------------------------------------------------*
2796 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: user-defined type
2797 .*---------------------------------------------------------------------*
2799 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: user-defined type>
2803 <MODULE TTCN ModuleA ModuleA.ttcn>
2807 boolean field2 optional
2809 external function MyExtFunc (
2810 MySet par_1, // user-defined type
2813 inout MySet par_4 );
2815 var MySet var_1 := { field1:=1.3 };
2816 var MySet var_2 := { field1:=2.5 };
2817 var MySet var_3 := { field1:=3.1 };
2818 var MySet var_4 := { field1:=4.9 };
2819 var MySet var_11, var_22, var_33, var_44;
2820 MyExtFunc(var_1,var_2,var_3,var_4); // good
2821 MyExtFunc(var_11,var_22,var_33,var_44); // good
2822 MyExtFunc( {field1:=1.2, field2:=true}, // good
2823 {field1:=2.5, field2:=true},
2826 MyExtFunc( {field1:=1.2, field2:=true}, // error
2827 {field1:=2.5, field2:=true},
2828 {field1:=3.6, field2:=true},
2829 {field1:=4.1, field2:=true});
2833 <RESULT IF_PASS COUNT 2>
2834 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2836 <RESULT IF_PASS COUNT 1>
2837 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2839 <RESULT IF_PASS COUNT 2>
2842 <RESULT IF_PASS POSITIVE>
2843 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2849 .*---------------------------------------------------------------------*
2850 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: address type
2851 .*---------------------------------------------------------------------*
2853 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: address type>
2857 <MODULE TTCN ModuleA ModuleA.ttcn>
2859 type record address { integer field }
2861 address par_1, // address type
2864 inout address par_4 ) {
2865 var address temp := { field:=par_1.field };
2866 par_1.field := par_2.field;
2867 par_2.field := par_3.field;
2868 par_3.field := par_4.field;
2869 par_4.field := temp.field;
2872 var address var_1 := { field:=1 };
2873 var address var_2 := { field:=2 };
2874 var address var_3 := { field:=3 };
2875 var address var_4 := { field:=4 };
2876 var address var_11, var_22, var_33, var_44;
2877 MyFunc( {1}, {2}, var_3, var_4 ); // good
2878 MyFunc( var_1, var_2, var_3, var_4 ); // good
2879 MyFunc( var_11, var_22, var_33, var_44 ); // good
2880 MyFunc( {1}, {2}, {3}, {4} ); // error
2884 <RESULT IF_PASS COUNT 2>
2885 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2887 <RESULT IF_PASS COUNT 1>
2888 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2890 <RESULT IF_PASS COUNT 2>
2893 <RESULT IF_PASS POSITIVE>
2894 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2900 .*---------------------------------------------------------------------*
2901 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: address type
2902 .*---------------------------------------------------------------------*
2904 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: address type>
2908 <MODULE TTCN ModuleA ModuleA.ttcn>
2910 type component MyCT {}
2911 type record address { integer field }
2912 function MyCompFunc (
2913 address par_1, // address type
2916 inout address par_4 ) runs on MyCT {
2917 var address temp := { field:=par_1.field };
2918 par_1.field := par_2.field;
2919 par_2.field := par_3.field;
2920 par_3.field := par_4.field;
2921 par_4.field := temp.field;
2923 function MyTempFunc () runs on MyCT {
2924 var address var_1 := { field:=1 };
2925 var address var_2 := { field:=2 };
2926 var address var_3 := { field:=3 };
2927 var address var_4 := { field:=4 };
2928 var address var_11, var_22, var_33, var_44;
2929 MyCompFunc( {1}, {2}, var_3, var_4 ); // good
2930 MyCompFunc( var_1, var_2, var_3, var_4 ); // good
2931 MyCompFunc( var_11, var_22, var_33, var_44 ); // good
2932 MyCompFunc( {1}, {2}, {3}, {4} ); // error
2936 <RESULT IF_PASS COUNT 2>
2937 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2939 <RESULT IF_PASS COUNT 1>
2940 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2942 <RESULT IF_PASS COUNT 2>
2945 <RESULT IF_PASS POSITIVE>
2946 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2952 .*---------------------------------------------------------------------*
2953 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: address type
2954 .*---------------------------------------------------------------------*
2956 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: address type>
2960 <MODULE TTCN ModuleA ModuleA.ttcn>
2962 type record address { integer field }
2963 external function MyExtFunc (
2964 address par_1, // address type
2967 inout address par_4 );
2969 var address var_1 := { field:=1 };
2970 var address var_2 := { field:=2 };
2971 var address var_3 := { field:=3 };
2972 var address var_4 := { field:=4 };
2973 var address var_11, var_22, var_33, var_44;
2974 MyExtFunc( {1}, {2}, var_3, var_4 ); // good
2975 MyExtFunc( var_1, var_2, var_3, var_4 ); // good
2976 MyExtFunc( var_11, var_22, var_33, var_44 ); // good
2977 MyExtFunc( {1}, {2}, {3}, {4} ); // error
2981 <RESULT IF_PASS COUNT 2>
2982 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
2984 <RESULT IF_PASS COUNT 1>
2985 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
2987 <RESULT IF_PASS COUNT 2>
2990 <RESULT IF_PASS POSITIVE>
2991 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
2997 .*---------------------------------------------------------------------*
2998 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: template
2999 .*---------------------------------------------------------------------*
3001 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: template>
3005 <MODULE TTCN ModuleA ModuleA.ttcn>
3008 template float par_1, // template
3009 in template float par_2,
3010 out template float par_3,
3011 inout template float par_4 ) {
3013 temp := valueof ( par_1 );
3014 temp := valueof ( par_2 );
3015 temp := valueof ( par_3 );
3016 temp := valueof ( par_4 );
3023 var float var_1 := 1.3;
3024 var float var_2 := 2.5;
3025 var float var_3 := 3.1;
3026 var float var_4 := 4.9;
3027 var template float var_11, var_22, var_33, var_44;
3029 MyFunc( 1.1, 2.8, var_33, var_44); // good
3030 MyFunc( var_11, var_22, var_33, var_44); // good
3031 MyFunc( var_1, var_2, var_3, var_4); // error
3032 MyFunc( 1.1, 2.8, 3.53, 4.94); // error
3036 <RESULT IF_PASS COUNT 4>
3037 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3039 <RESULT IF_PASS COUNT 2>
3040 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3042 <RESULT IF_PASS COUNT 4>
3045 <RESULT IF_PASS POSITIVE>
3046 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3052 .*---------------------------------------------------------------------*
3053 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: template
3054 .*---------------------------------------------------------------------*
3056 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: template>
3060 <MODULE TTCN ModuleA ModuleA.ttcn>
3062 type component MyCT {}
3063 function MyCompFunc (
3064 template float par_1, // template
3065 in template float par_2,
3066 out template float par_3,
3067 inout template float par_4 ) runs on MyCT {
3069 temp := valueof ( par_1 );
3070 temp := valueof ( par_2 );
3071 temp := valueof ( par_3 );
3072 temp := valueof ( par_4 );
3078 function MyTempFunc () runs on MyCT {
3079 var float var_1 := 1.3;
3080 var float var_2 := 2.5;
3081 var float var_3 := 3.1;
3082 var float var_4 := 4.9;
3083 var template float var_11, var_22, var_33, var_44;
3085 MyCompFunc( 1.1, 2.8, var_33, var_44); // good
3086 MyCompFunc( var_11, var_22, var_33, var_44); // good
3087 MyCompFunc( var_1, var_2, var_3, var_4); // error
3088 MyCompFunc( 1.1, 2.8, 3.53, 4.94); // error
3092 <RESULT IF_PASS COUNT 4>
3093 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3095 <RESULT IF_PASS COUNT 2>
3096 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3098 <RESULT IF_PASS COUNT 4>
3101 <RESULT IF_PASS POSITIVE>
3102 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3108 .*---------------------------------------------------------------------*
3109 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: template
3110 .*---------------------------------------------------------------------*
3112 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: template>
3116 <MODULE TTCN ModuleA ModuleA.ttcn>
3118 external function MyExtFunc (
3119 template float par_1, // template
3120 in template float par_2,
3121 out template float par_3,
3122 inout template float par_4 );
3124 var float var_1 := 1.3;
3125 var float var_2 := 2.5;
3126 var float var_3 := 3.1;
3127 var float var_4 := 4.9;
3128 var template float var_11, var_22, var_33, var_44;
3130 MyExtFunc( 1.1, 2.8, var_33, var_44); // good
3131 MyExtFunc( var_11, var_22, var_33, var_44); // good
3132 MyExtFunc( var_1, var_2, var_3, var_4); // error
3133 MyExtFunc( 1.1, 2.8, 3.53, 4.94); // error
3137 <RESULT IF_PASS COUNT 4>
3138 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3140 <RESULT IF_PASS COUNT 2>
3141 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3143 <RESULT IF_PASS COUNT 4>
3146 <RESULT IF_PASS POSITIVE>
3147 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3153 .*---------------------------------------------------------------------*
3154 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: component type
3155 .*---------------------------------------------------------------------*
3157 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: component type>
3161 <MODULE TTCN ModuleA ModuleA.ttcn>
3163 type component MyCT {}
3165 MyCT par_1, // component type
3168 inout MyCT par_4 ) {
3169 var MyCT temp := par_1;
3175 function MyCompFunc () runs on MyCT {
3176 var MyCT temp, var_1, var_2, var_3, var_4;
3177 temp := MyCT.create;
3178 MyFunc( var_1, var_2, var_3, var_4 ); // good
3179 MyFunc( temp, temp, temp, temp); // good
3180 MyFunc( MyCT.create, MyCT.create, temp, temp ); // good
3181 MyFunc( MyCT.create, MyCT.create, MyCT.create, MyCT.create ); // error
3185 <RESULT IF_PASS COUNT 2>
3186 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3188 <RESULT IF_PASS COUNT 1>
3189 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3191 <RESULT IF_PASS COUNT 2>
3194 <RESULT IF_PASS POSITIVE>
3195 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3201 .*---------------------------------------------------------------------*
3202 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: component type
3203 .*---------------------------------------------------------------------*
3205 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: component type>
3209 <MODULE TTCN ModuleA ModuleA.ttcn>
3211 type component MyCT {}
3212 function MyCompFunc (
3213 MyCT par_1, // component type
3216 inout MyCT par_4 ) runs on MyCT {
3217 var MyCT temp := par_1;
3223 function MyTempFunc () runs on MyCT {
3224 var MyCT temp, var_1, var_2, var_3, var_4;
3225 temp := MyCT.create;
3226 MyCompFunc( var_1, var_2, var_3, var_4 ); // good
3227 MyCompFunc( temp, temp, temp, temp); // good
3228 MyCompFunc( MyCT.create, MyCT.create, temp, temp ); // good
3229 MyCompFunc( MyCT.create, MyCT.create, MyCT.create, MyCT.create ); // error
3233 <RESULT IF_PASS COUNT 2>
3234 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3236 <RESULT IF_PASS COUNT 1>
3237 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3239 <RESULT IF_PASS COUNT 2>
3242 <RESULT IF_PASS POSITIVE>
3243 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3249 .*---------------------------------------------------------------------*
3250 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: component type
3251 .*---------------------------------------------------------------------*
3253 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: component type>
3257 <MODULE TTCN ModuleA ModuleA.ttcn>
3259 type component MyCT {}
3260 external function MyExtFunc (
3261 MyCT par_1, // component type
3265 function MyTempFunc () runs on MyCT {
3266 var MyCT temp, var_1, var_2, var_3, var_4;
3267 temp := MyCT.create;
3268 MyExtFunc( var_1, var_2, var_3, var_4 ); // good
3269 MyExtFunc( temp, temp, temp, temp); // good
3270 MyExtFunc( MyCT.create, MyCT.create, temp, temp ); // good
3271 MyExtFunc( MyCT.create, MyCT.create, MyCT.create, MyCT.create ); // error
3275 <RESULT IF_PASS COUNT 2>
3276 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3278 <RESULT IF_PASS COUNT 1>
3279 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3281 <RESULT IF_PASS COUNT 2>
3284 <RESULT IF_PASS POSITIVE>
3285 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3291 .*---------------------------------------------------------------------*
3292 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: port type
3293 .*---------------------------------------------------------------------*
3295 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: port type>
3299 <MODULE TTCN ModuleA ModuleA.ttcn>
3301 type port MyPort message { inout charstring; } // port type
3302 type component MyCT {
3306 function MyFunc ( MyPort par_1, inout MyPort par_2 ) {
3310 function MyCompFunc ( MyPort par_1, inout MyPort par_2 ) runs on MyCT {
3315 external function MyExtFunc ( MyPort par_1, inout MyPort par_2 );
3316 function MyTempFunc ( MyPort par_1, inout MyPort par_2 ) runs on MyCT {
3317 MyFunc( port_1, port_2 );
3318 MyCompFunc( port_1, port_2 );
3319 MyExtFunc( port_1, port_2 );
3323 <RESULT IF_PASS COUNT 1>
3324 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?port_1
3326 <RESULT IF_PASS COUNT 2>
3327 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1
3329 <RESULT IF_PASS COUNT 2>
3330 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2
3332 <RESULT IF_PASS COUNT 5>
3335 <RESULT IF_PASS POSITIVE>
3336 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3342 .*---------------------------------------------------------------------*
3343 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: default
3344 .*---------------------------------------------------------------------*
3346 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: default>
3350 <MODULE TTCN ModuleA ModuleA.ttcn>
3353 default par_1, // default
3356 inout default par_4 ) {
3357 var default temp := par_1;
3364 var default var_1, var_2, var_3, var_4;
3365 var default temp := null;
3366 MyFunc( var_1, var_2, var_3, var_4 ); // good
3367 MyFunc( temp, temp, temp, temp); // good
3368 MyFunc( null, null, temp, temp); // good
3369 MyFunc( null, null, null, null); // error
3373 <RESULT IF_PASS COUNT 2>
3374 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3376 <RESULT IF_PASS COUNT 1>
3377 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3379 <RESULT IF_PASS COUNT 2>
3382 <RESULT IF_PASS POSITIVE>
3383 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3389 .*---------------------------------------------------------------------*
3390 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: default
3391 .*---------------------------------------------------------------------*
3393 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: default>
3397 <MODULE TTCN ModuleA ModuleA.ttcn>
3399 type component MyCT {}
3400 function MyCompFunc (
3401 default par_1, // default type
3404 inout default par_4 ) runs on MyCT {
3405 var default temp := par_1;
3411 function MyTempFunc () runs on MyCT {
3412 var default var_1, var_2, var_3, var_4;
3413 var default temp := null;
3414 MyCompFunc( var_1, var_2, var_3, var_4 ); // good
3415 MyCompFunc( temp, temp, temp, temp); // good
3416 MyCompFunc( null, null, temp, temp); // good
3417 MyCompFunc( null, null, null, null); // error
3421 <RESULT IF_PASS COUNT 2>
3422 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3424 <RESULT IF_PASS COUNT 1>
3425 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3427 <RESULT IF_PASS COUNT 2>
3430 <RESULT IF_PASS POSITIVE>
3431 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3437 .*---------------------------------------------------------------------*
3438 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: default
3439 .*---------------------------------------------------------------------*
3441 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: default>
3445 <MODULE TTCN ModuleA ModuleA.ttcn>
3447 external function MyExtFunc (
3448 default par_1, // default type
3451 inout default par_4 );
3453 var default var_1, var_2, var_3, var_4;
3454 var default temp := null;
3455 MyExtFunc( var_1, var_2, var_3, var_4 ); // good
3456 MyExtFunc( temp, temp, temp, temp); // good
3457 MyExtFunc( null, null, temp, temp); // good
3458 MyExtFunc( null, null, null, null); // error
3462 <RESULT IF_PASS COUNT 2>
3463 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3465 <RESULT IF_PASS COUNT 1>
3466 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3468 <RESULT IF_PASS COUNT 2>
3471 <RESULT IF_PASS POSITIVE>
3472 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3478 .*---------------------------------------------------------------------*
3479 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: timer
3480 .*---------------------------------------------------------------------*
3482 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: timer>
3486 <MODULE TTCN ModuleA ModuleA.ttcn>
3488 type component MyCT {}
3489 function MyFunc ( timer par_1, inout timer par_2 ) {
3491 temp := par_1; // error
3492 par_1 := par_2; // error
3493 par_2 := temp; // error
3499 MyFunc( T1, T2 ); // good
3500 MyFunc( T3, T4 ); // good
3501 MyFunc( 3.8, 4.5 ); // error
3505 <RESULT IF_PASS COUNT 1>
3506 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?temp
3508 <RESULT IF_PASS COUNT 1>
3509 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1
3511 <RESULT IF_PASS COUNT 1>
3512 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2
3514 <RESULT IF_PASS COUNT 2>
3515 (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter
3517 <RESULT IF_PASS COUNT 5>
3520 <RESULT IF_PASS POSITIVE>
3521 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3527 .*---------------------------------------------------------------------*
3528 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: timer as non-mandatory parameter
3529 .*---------------------------------------------------------------------*
3531 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function: timer as non-mandatory parameter>
3535 <MODULE TTCN ModuleA ModuleA.ttcn>
3538 timer par_1 := 1.0, // basic type
3539 inout timer par_4 := 1.0 ) {};
3542 <RESULT IF_PASS COUNT 2>
3543 (?im)\berror\b.+?Reference.+?timer.+?expected.+?for.+?parameter
3545 <RESULT IF_PASS COUNT 2>
3548 <RESULT IF_PASS POSITIVE>
3549 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3555 .*---------------------------------------------------------------------*
3556 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: timer
3557 .*---------------------------------------------------------------------*
3559 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: timer>
3563 <MODULE TTCN ModuleA ModuleA.ttcn>
3565 type component MyCT {}
3566 function MyCompFunc ( timer par_1, inout timer par_2 ) runs on MyCT {
3568 temp := par_1; // error
3569 par_1 := par_2; // error
3570 par_2 := temp; // error
3572 function MyTempFunc () runs on MyCT {
3576 MyCompFunc( T1, T2 ); // good
3577 MyCompFunc( T3, T4 ); // good
3578 MyCompFunc( 3.8, 4.5 ); // error
3582 <RESULT IF_PASS COUNT 1>
3583 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?temp
3585 <RESULT IF_PASS COUNT 1>
3586 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1
3588 <RESULT IF_PASS COUNT 1>
3589 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2
3591 <RESULT IF_PASS COUNT 2>
3592 (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter
3594 <RESULT IF_PASS COUNT 5>
3597 <RESULT IF_PASS POSITIVE>
3598 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3604 .*---------------------------------------------------------------------*
3605 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: timer
3606 .*---------------------------------------------------------------------*
3608 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: timer>
3612 <MODULE TTCN ModuleA ModuleA.ttcn>
3614 type component MyCT {}
3615 external function MyExtFunc ( timer par_1, inout timer par_2 );
3620 MyExtFunc( T1, T2 ); // good
3621 MyExtFunc( T3, T4 ); // good
3622 MyExtFunc( 3.8, 4.5 ); // error
3626 <RESULT IF_PASS COUNT 2>
3627 (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter
3629 <RESULT IF_PASS COUNT 2>
3632 <RESULT IF_PASS POSITIVE>
3633 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3639 .*---------------------------------------------------------------------*
3640 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: allowed in/out/inout
3641 .*---------------------------------------------------------------------*
3643 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: allowed in/out/inout>
3647 <MODULE TTCN ModuleA ModuleA.ttcn>
3649 type port MyPort message { inout charstring; }
3650 type component MyCT {}
3653 boolean field2 optional
3655 type record address { integer field }
3657 integer par_11_1, // basic type
3658 in integer par_12_1,
3659 out integer par_13_1,
3660 inout integer par_14_1,
3662 octetstring par_11_2, // basic string type
3663 in octetstring par_12_2,
3664 out octetstring par_13_2,
3665 inout octetstring par_14_2,
3667 MySet par_21, // user-defined structured type
3672 address par_31, // address
3675 inout address par_34,
3677 template MySet par_41, // template
3678 in template MySet par_42,
3679 out template MySet par_43,
3680 inout template MySet par_44,
3682 MyCT par_51, // component type
3687 MyPort par_61, // port type
3688 inout MyPort par_64,
3690 default par_71, // default
3693 inout default par_74,
3695 timer par_81, // timer
3696 inout timer par_84 ) {
3701 <RESULT IF_PASS POSITIVE>
3702 (?im)\bnotify\b.+?Generating.+?code
3708 .*---------------------------------------------------------------------*
3709 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: allowed in/out/inout
3710 .*---------------------------------------------------------------------*
3712 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: allowed in/out/inout>
3716 <MODULE TTCN ModuleA ModuleA.ttcn>
3718 type port MyPort message { inout charstring; }
3719 type component MyCT {}
3722 boolean field2 optional
3724 type record address { integer field }
3725 altstep MyCompAltstep (
3726 integer par_11_1, // basic type
3727 in integer par_12_1,
3728 out integer par_13_1,
3729 inout integer par_14_1,
3731 octetstring par_11_2, // basic string type
3732 in octetstring par_12_2,
3733 out octetstring par_13_2,
3734 inout octetstring par_14_2,
3736 MySet par_21, // user-defined structured type
3741 address par_31, // address
3744 inout address par_34,
3746 template MySet par_41, // template
3747 in template MySet par_42,
3748 out template MySet par_43,
3749 inout template MySet par_44,
3751 MyCT par_51, // component type
3756 MyPort par_61, // port type
3757 inout MyPort par_64,
3759 default par_71, // default
3762 inout default par_74,
3764 timer par_81, // timer
3765 inout timer par_84 ) runs on MyCT {
3770 <RESULT IF_PASS POSITIVE>
3771 (?im)\bnotify\b.+?Generating.+?code
3777 .*---------------------------------------------------------------------*
3778 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: allowed non-mandatory in/out/inout
3779 .*---------------------------------------------------------------------*
3781 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: allowed non-mandatory in/out/inout>
3785 <MODULE TTCN ModuleA ModuleA.ttcn>
3787 type port MyPort message { inout charstring; }
3790 boolean field2 optional
3792 type record address { integer field }
3793 type component MyCT {
3794 const integer comp_const_i := 0;
3795 var integer comp_var_i := 0;
3796 const octetstring comp_const_o := '00'O;
3797 var octetstring comp_var_o := '00'O;
3798 const MySet comp_const_set := {field1 := 1.0, field2 := true};
3799 var MySet comp_var_set := {field1 := 1.0, field2 := true};
3800 const address comp_const_address := {5};
3801 var address comp_var_address := {5};
3802 port MyPort comp_port;
3803 timer comp_timer := 1.0;
3805 altstep MyCompAltstep (
3806 integer par_11_1 := comp_const_i, // basic type
3807 in integer par_12_1 := comp_const_i,
3808 out integer par_13_1 := comp_var_i,
3809 inout integer par_14_1 := comp_var_i,
3811 octetstring par_11_2 := comp_const_o, // basic string type
3812 in octetstring par_12_2 := comp_const_o,
3813 out octetstring par_13_2 := comp_var_o,
3814 inout octetstring par_14_2 := comp_var_o,
3816 MySet par_21 := comp_const_set, // user-defined structured type
3817 in MySet par_22 := comp_const_set,
3818 out MySet par_23 := comp_var_set,
3819 inout MySet par_24 := comp_var_set,
3821 address par_31 := comp_const_address, // address
3822 in address par_32 := comp_const_address,
3823 out address par_33 := comp_var_address,
3824 inout address par_34 := comp_var_address,
3826 MyPort par_61 := comp_port, // port type
3827 inout MyPort par_64 := comp_port,
3829 timer par_81 := comp_timer, // timer
3830 inout timer par_84 := comp_timer ) runs on MyCT {
3835 <RESULT IF_PASS POSITIVE>
3836 (?im)\bnotify\b.+?Generating.+?code
3842 .*---------------------------------------------------------------------*
3843 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: port type with in/out
3844 .*---------------------------------------------------------------------*
3846 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: port type with in/out>
3850 <MODULE TTCN ModuleA ModuleA.ttcn>
3852 type port MyPort message { inout charstring; }
3853 type component MyCT {}
3854 altstep MyFunc ( in MyPort par_1, out MyPort par_2 ) {
3857 altstep MyCompFunc ( in MyPort par_1, out MyPort par_2 ) {
3862 <RESULT IF_PASS COUNT 4>
3863 (?im)\berror\b.+?Port.+?cannot.+?used.+?value
3865 <RESULT IF_PASS COUNT 2>
3866 (?im)\berror\b.+?Port.+?cannot.+?used.+?out.+?value
3868 <RESULT IF_PASS COUNT 4>
3871 <RESULT IF_PASS POSITIVE>
3872 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3878 .*---------------------------------------------------------------------*
3879 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: timer with in/out
3880 .*---------------------------------------------------------------------*
3882 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: timer with in/out>
3886 <MODULE TTCN ModuleA ModuleA.ttcn>
3888 type component MyCT {}
3889 altstep MyFunc ( in timer par_1, out timer par_2 ) {
3892 altstep MyCompFunc ( in timer par_1, out timer par_2 ) {
3897 <RESULT IF_PASS COUNT 4>
3898 (?im)\berror\b.+?syntax.+?error
3900 <RESULT IF_PASS COUNT 4>
3907 .*---------------------------------------------------------------------*
3908 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: basic type
3909 .*---------------------------------------------------------------------*
3911 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: basic type>
3915 <MODULE TTCN ModuleA ModuleA.ttcn>
3918 integer par_1, // basic type
3921 inout integer par_4 ) {
3922 var integer temp := par_1;
3931 var integer var_1 := 1;
3932 var integer var_2 := 2;
3933 var integer var_3 := 3;
3934 var integer var_4 := 4;
3935 var integer var_11, var_22, var_33, var_44;
3936 MyAltstep( var_1, var_2, var_3, var_4); // good
3937 MyAltstep( var_11, var_22, var_33, var_44); // good
3938 MyAltstep( 1, 2, var_3, var_4); // good
3939 MyAltstep( 1, 2, 3, 4); // error
3943 <RESULT IF_PASS COUNT 2>
3944 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3946 <RESULT IF_PASS COUNT 1>
3947 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3949 <RESULT IF_PASS COUNT 2>
3952 <RESULT IF_PASS POSITIVE>
3953 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3959 .*---------------------------------------------------------------------*
3960 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: basic type as non-mandatory parameter
3961 .*---------------------------------------------------------------------*
3963 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: basic type as non-mandatory parameter>
3967 <MODULE TTCN ModuleA ModuleA.ttcn>
3970 integer par_1 := 1, // basic type
3971 in integer par_2 := 1,
3972 out integer par_3 := 1,
3973 inout integer par_4 := 1 ) {
3978 <RESULT IF_PASS COUNT 2>
3979 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
3981 <RESULT IF_PASS COUNT 1>
3982 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
3984 <RESULT IF_PASS COUNT 2>
3987 <RESULT IF_PASS POSITIVE>
3988 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
3994 .*---------------------------------------------------------------------*
3995 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: basic type
3996 .*---------------------------------------------------------------------*
3998 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: basic type>
4002 <MODULE TTCN ModuleA ModuleA.ttcn>
4004 type component MyCT {}
4005 altstep MyCompAltstep (
4006 integer par_1, // basic type
4009 inout integer par_4 ) runs on MyCT {
4010 var integer temp := par_1;
4018 function MyCompFunc () runs on MyCT {
4019 var integer var_1 := 1;
4020 var integer var_2 := 2;
4021 var integer var_3 := 3;
4022 var integer var_4 := 4;
4023 var integer var_11, var_22, var_33, var_44;
4024 MyCompAltstep( var_1, var_2, var_3, var_4); // good
4025 MyCompAltstep( var_11, var_22, var_33, var_44); // good
4026 MyCompAltstep( 1, 2, var_3, var_4); // good
4027 MyCompAltstep( 1, 2, 3, 4); // error
4031 <RESULT IF_PASS COUNT 2>
4032 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4034 <RESULT IF_PASS COUNT 1>
4035 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4037 <RESULT IF_PASS COUNT 2>
4040 <RESULT IF_PASS POSITIVE>
4041 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4047 .*---------------------------------------------------------------------*
4048 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: basic string type
4049 .*---------------------------------------------------------------------*
4051 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: basic string type>
4055 <MODULE TTCN ModuleA ModuleA.ttcn>
4058 charstring par_1, // basic string type
4059 in charstring par_2,
4060 out charstring par_3,
4061 inout charstring par_4 ) {
4062 var charstring temp := par_1;
4071 var charstring var_1 := "q";
4072 var charstring var_2 := "w";
4073 var charstring var_3 := "e";
4074 var charstring var_4 := "r";
4075 var charstring var_11, var_22, var_33, var_44;
4076 MyAltstep( var_1, var_2, var_3, var_4); // good
4077 MyAltstep( var_11, var_22, var_33, var_44); // good
4078 MyAltstep( "w", "e", var_3, var_4); // good
4079 MyAltstep( "q", "b", "5", "w"); // error
4083 <RESULT IF_PASS COUNT 2>
4084 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4086 <RESULT IF_PASS COUNT 1>
4087 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4089 <RESULT IF_PASS COUNT 2>
4092 <RESULT IF_PASS POSITIVE>
4093 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4099 .*---------------------------------------------------------------------*
4100 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: basic string type
4101 .*---------------------------------------------------------------------*
4103 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: basic string type>
4107 <MODULE TTCN ModuleA ModuleA.ttcn>
4109 type component MyCT {}
4110 altstep MyCompAltstep (
4111 charstring par_1, // basic string type
4112 in charstring par_2,
4113 out charstring par_3,
4114 inout charstring par_4 ) runs on MyCT {
4115 var charstring temp := par_1;
4123 function MyCompFunc () runs on MyCT {
4124 var charstring var_1 := "q";
4125 var charstring var_2 := "w";
4126 var charstring var_3 := "e";
4127 var charstring var_4 := "r";
4128 var charstring var_11, var_22, var_33, var_44;
4129 MyCompAltstep( var_1, var_2, var_3, var_4); // good
4130 MyCompAltstep( var_11, var_22, var_33, var_44); // good
4131 MyCompAltstep( "w", "e", var_3, var_4); // good
4132 MyCompAltstep( "q", "b", "5", "w"); // error
4136 <RESULT IF_PASS COUNT 2>
4137 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4139 <RESULT IF_PASS COUNT 1>
4140 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4142 <RESULT IF_PASS COUNT 2>
4145 <RESULT IF_PASS POSITIVE>
4146 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4152 .*---------------------------------------------------------------------*
4153 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: user-defined type
4154 .*---------------------------------------------------------------------*
4156 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: user-defined type>
4160 <MODULE TTCN ModuleA ModuleA.ttcn>
4164 boolean field2 optional
4167 MySet par_1, // user-defined type
4170 inout MySet par_4 ) {
4171 var MySet temp := { field1:=par_1.field1 }
4173 par_1.field1 := par_2.field1;
4174 par_2.field1 := par_3.field1;
4175 par_3.field1 := par_4.field1;
4176 par_4.field1 := temp.field1;
4180 var MySet var_1 := { field1:=1.3 };
4181 var MySet var_2 := { field1:=2.5 };
4182 var MySet var_3 := { field1:=3.1 };
4183 var MySet var_4 := { field1:=4.9 };
4184 var MySet var_11, var_22, var_33, var_44;
4185 MyAltstep(var_1,var_2,var_3,var_4); // good
4186 MyAltstep(var_11,var_22,var_33,var_44); // good
4187 MyAltstep( {field1:=1.2, field2:=true}, // good
4188 {field1:=2.5, field2:=true},
4191 MyAltstep( {field1:=1.2, field2:=true}, // error
4192 {field1:=2.5, field2:=true},
4193 {field1:=3.6, field2:=true},
4194 {field1:=4.1, field2:=true});
4198 <RESULT IF_PASS COUNT 2>
4199 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4201 <RESULT IF_PASS COUNT 1>
4202 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4204 <RESULT IF_PASS COUNT 2>
4207 <RESULT IF_PASS POSITIVE>
4208 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4214 .*---------------------------------------------------------------------*
4215 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: user-defined type
4216 .*---------------------------------------------------------------------*
4218 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: user-defined type>
4222 <MODULE TTCN ModuleA ModuleA.ttcn>
4224 type component MyCT {}
4227 boolean field2 optional
4229 altstep MyCompAltstep (
4230 MySet par_1, // user-defined type
4233 inout MySet par_4 ) runs on MyCT {
4234 var MySet temp := { field1:=par_1.field1 }
4236 par_1.field1 := par_2.field1;
4237 par_2.field1 := par_3.field1;
4238 par_3.field1 := par_4.field1;
4239 par_4.field1 := temp.field1;
4242 function MyCompFunc () runs on MyCT {
4243 var MySet var_1 := { field1:=1.3 };
4244 var MySet var_2 := { field1:=2.5 };
4245 var MySet var_3 := { field1:=3.1 };
4246 var MySet var_4 := { field1:=4.9 };
4247 var MySet var_11, var_22, var_33, var_44;
4248 MyCompAltstep(var_1,var_2,var_3,var_4); // good
4249 MyCompAltstep(var_11,var_22,var_33,var_44); // good
4250 MyCompAltstep( {field1:=1.2, field2:=true}, // good
4251 {field1:=2.5, field2:=true},
4254 MyCompAltstep( {field1:=1.2, field2:=true}, // error
4255 {field1:=2.5, field2:=true},
4256 {field1:=3.6, field2:=true},
4257 {field1:=4.1, field2:=true});
4261 <RESULT IF_PASS COUNT 2>
4262 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4264 <RESULT IF_PASS COUNT 1>
4265 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4267 <RESULT IF_PASS COUNT 2>
4270 <RESULT IF_PASS POSITIVE>
4271 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4277 .*---------------------------------------------------------------------*
4278 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: address type
4279 .*---------------------------------------------------------------------*
4281 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: address type>
4285 <MODULE TTCN ModuleA ModuleA.ttcn>
4287 type record address { integer field }
4289 address par_1, // address type
4292 inout address par_4 ) {
4293 var address temp := { field:=par_1.field };
4295 par_1.field := par_2.field;
4296 par_2.field := par_3.field;
4297 par_3.field := par_4.field;
4298 par_4.field := temp.field;
4302 var address var_1 := { field:=1 };
4303 var address var_2 := { field:=2 };
4304 var address var_3 := { field:=3 };
4305 var address var_4 := { field:=4 };
4306 var address var_11, var_22, var_33, var_44;
4307 MyAltstep( {1}, {2}, var_3, var_4 ); // good
4308 MyAltstep( var_1, var_2, var_3, var_4 ); // good
4309 MyAltstep( var_11, var_22, var_33, var_44 ); // good
4310 MyAltstep( {1}, {2}, {3}, {4} ); // error
4314 <RESULT IF_PASS COUNT 2>
4315 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4317 <RESULT IF_PASS COUNT 1>
4318 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4320 <RESULT IF_PASS COUNT 2>
4323 <RESULT IF_PASS POSITIVE>
4324 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4330 .*---------------------------------------------------------------------*
4331 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: address type
4332 .*---------------------------------------------------------------------*
4334 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: address type>
4338 <MODULE TTCN ModuleA ModuleA.ttcn>
4340 type component MyCT {}
4341 type record address { integer field }
4342 altstep MyCompAltstep (
4343 address par_1, // address type
4346 inout address par_4 ) runs on MyCT {
4347 var address temp := { field:=par_1.field };
4349 par_1.field := par_2.field;
4350 par_2.field := par_3.field;
4351 par_3.field := par_4.field;
4352 par_4.field := temp.field;
4355 function MyCompFunc () runs on MyCT {
4356 var address var_1 := { field:=1 };
4357 var address var_2 := { field:=2 };
4358 var address var_3 := { field:=3 };
4359 var address var_4 := { field:=4 };
4360 var address var_11, var_22, var_33, var_44;
4361 MyCompAltstep( {1}, {2}, var_3, var_4 ); // good
4362 MyCompAltstep( var_1, var_2, var_3, var_4 ); // good
4363 MyCompAltstep( var_11, var_22, var_33, var_44 ); // good
4364 MyCompAltstep( {1}, {2}, {3}, {4} ); // error
4368 <RESULT IF_PASS COUNT 2>
4369 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4371 <RESULT IF_PASS COUNT 1>
4372 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4374 <RESULT IF_PASS COUNT 2>
4377 <RESULT IF_PASS POSITIVE>
4378 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4384 .*---------------------------------------------------------------------*
4385 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: template
4386 .*---------------------------------------------------------------------*
4388 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: template>
4392 <MODULE TTCN ModuleA ModuleA.ttcn>
4395 template float par_1, // template
4396 in template float par_2,
4397 out template float par_3,
4398 inout template float par_4 ) {
4401 temp := valueof ( par_1 );
4402 temp := valueof ( par_2 );
4403 temp := valueof ( par_3 );
4404 temp := valueof ( par_4 );
4412 var float var_1 := 1.3;
4413 var float var_2 := 2.5;
4414 var float var_3 := 3.1;
4415 var float var_4 := 4.9;
4416 var template float var_11, var_22, var_33, var_44;
4418 MyAltstep( 1.1, 2.8, var_33, var_44); // good
4419 MyAltstep( var_11, var_22, var_33, var_44); // good
4420 MyAltstep( var_1, var_2, var_3, var_4); // error
4421 MyAltstep( 1.1, 2.8, 3.53, 4.94); // error
4425 <RESULT IF_PASS COUNT 4>
4426 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4428 <RESULT IF_PASS COUNT 2>
4429 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4431 <RESULT IF_PASS COUNT 4>
4434 <RESULT IF_PASS POSITIVE>
4435 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4441 .*---------------------------------------------------------------------*
4442 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: template
4443 .*---------------------------------------------------------------------*
4445 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: template>
4449 <MODULE TTCN ModuleA ModuleA.ttcn>
4451 type component MyCT {}
4452 altstep MyCompAltstep (
4453 template float par_1, // template
4454 in template float par_2,
4455 out template float par_3,
4456 inout template float par_4 ) runs on MyCT {
4459 temp := valueof ( par_1 );
4460 temp := valueof ( par_2 );
4461 temp := valueof ( par_3 );
4462 temp := valueof ( par_4 );
4469 function MyCompFunc () runs on MyCT {
4470 var float var_1 := 1.3;
4471 var float var_2 := 2.5;
4472 var float var_3 := 3.1;
4473 var float var_4 := 4.9;
4474 var template float var_11, var_22, var_33, var_44;
4476 MyCompAltstep( 1.1, 2.8, var_33, var_44); // good
4477 MyCompAltstep( var_11, var_22, var_33, var_44); // good
4478 MyCompAltstep( var_1, var_2, var_3, var_4); // error
4479 MyCompAltstep( 1.1, 2.8, 3.53, 4.94); // error
4483 <RESULT IF_PASS COUNT 4>
4484 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4486 <RESULT IF_PASS COUNT 2>
4487 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4489 <RESULT IF_PASS COUNT 4>
4492 <RESULT IF_PASS POSITIVE>
4493 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4499 .*---------------------------------------------------------------------*
4500 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: component type
4501 .*---------------------------------------------------------------------*
4503 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: component type>
4507 <MODULE TTCN ModuleA ModuleA.ttcn>
4509 type component MyCT {}
4511 MyCT par_1, // component type
4514 inout MyCT par_4 ) {
4515 var MyCT temp := par_1;
4523 function MyCompFunc () runs on MyCT {
4524 var MyCT temp, var_1, var_2, var_3, var_4;
4525 temp := MyCT.create;
4526 MyAltstep( var_1, var_2, var_3, var_4 ); // good
4527 MyAltstep( temp, temp, temp, temp); // good
4528 MyAltstep( MyCT.create, MyCT.create, temp, temp ); // good
4529 MyAltstep( MyCT.create, MyCT.create, MyCT.create, MyCT.create ); // error
4533 <RESULT IF_PASS COUNT 2>
4534 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4536 <RESULT IF_PASS COUNT 1>
4537 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4539 <RESULT IF_PASS COUNT 2>
4542 <RESULT IF_PASS POSITIVE>
4543 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4549 .*---------------------------------------------------------------------*
4550 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: component type
4551 .*---------------------------------------------------------------------*
4553 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: component type>
4557 <MODULE TTCN ModuleA ModuleA.ttcn>
4559 type component MyCT {}
4560 altstep MyCompAltstep (
4561 MyCT par_1, // component type
4564 inout MyCT par_4 ) runs on MyCT {
4565 var MyCT temp := par_1;
4573 function MyCompFunc () runs on MyCT {
4574 var MyCT temp, var_1, var_2, var_3, var_4;
4575 temp := MyCT.create;
4576 MyCompAltstep( var_1, var_2, var_3, var_4 ); // good
4577 MyCompAltstep( temp, temp, temp, temp); // good
4578 MyCompAltstep( MyCT.create, MyCT.create, temp, temp ); // good
4579 MyCompAltstep( MyCT.create, MyCT.create, MyCT.create, MyCT.create ); // error
4583 <RESULT IF_PASS COUNT 2>
4584 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4586 <RESULT IF_PASS COUNT 1>
4587 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4589 <RESULT IF_PASS COUNT 2>
4592 <RESULT IF_PASS POSITIVE>
4593 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4599 .*---------------------------------------------------------------------*
4600 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: port type
4601 .*---------------------------------------------------------------------*
4603 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: port type>
4607 <MODULE TTCN ModuleA ModuleA.ttcn>
4609 type port MyPort message { inout charstring; } // port type
4610 type component MyCT {
4614 altstep MyAltstep ( MyPort par_1, inout MyPort par_2 ) {
4620 altstep MyCompAltstep ( MyPort par_1, inout MyPort par_2 ) runs on MyCT {
4627 function MyCompFunc ( MyPort par_1, inout MyPort par_2 ) runs on MyCT {
4628 MyAltstep( port_1, port_2 );
4629 MyCompAltstep( port_1, port_2 );
4633 <RESULT IF_PASS COUNT 1>
4634 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?port_1
4636 <RESULT IF_PASS COUNT 2>
4637 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1
4639 <RESULT IF_PASS COUNT 2>
4640 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2
4642 <RESULT IF_PASS COUNT 5>
4645 <RESULT IF_PASS POSITIVE>
4646 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4652 .*---------------------------------------------------------------------*
4653 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: default
4654 .*---------------------------------------------------------------------*
4656 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: default>
4660 <MODULE TTCN ModuleA ModuleA.ttcn>
4663 default par_1, // default
4666 inout default par_4 ) {
4667 var default temp := par_1;
4676 var default var_1, var_2, var_3, var_4;
4677 var default temp := null;
4678 MyAltstep( var_1, var_2, var_3, var_4 ); // good
4679 MyAltstep( temp, temp, temp, temp); // good
4680 MyAltstep( null, null, temp, temp); // good
4681 MyAltstep( null, null, null, null); // error
4685 <RESULT IF_PASS COUNT 2>
4686 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4688 <RESULT IF_PASS COUNT 1>
4689 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4691 <RESULT IF_PASS COUNT 2>
4694 <RESULT IF_PASS POSITIVE>
4695 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4701 .*---------------------------------------------------------------------*
4702 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: default
4703 .*---------------------------------------------------------------------*
4705 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: default>
4709 <MODULE TTCN ModuleA ModuleA.ttcn>
4711 type component MyCT {}
4712 altstep MyCompAltstep (
4713 default par_1, // default type
4716 inout default par_4 ) runs on MyCT {
4717 var default temp := par_1;
4725 function MyCompFunc () runs on MyCT {
4726 var default var_1, var_2, var_3, var_4;
4727 var default temp := null;
4728 MyCompAltstep( var_1, var_2, var_3, var_4 ); // good
4729 MyCompAltstep( temp, temp, temp, temp); // good
4730 MyCompAltstep( null, null, temp, temp); // good
4731 MyCompAltstep( null, null, null, null); // error
4735 <RESULT IF_PASS COUNT 2>
4736 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
4738 <RESULT IF_PASS COUNT 1>
4739 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
4741 <RESULT IF_PASS COUNT 2>
4744 <RESULT IF_PASS POSITIVE>
4745 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4751 .*---------------------------------------------------------------------*
4752 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: timer
4753 .*---------------------------------------------------------------------*
4755 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: timer>
4759 <MODULE TTCN ModuleA ModuleA.ttcn>
4761 type component MyCT {}
4762 altstep MyAltstep ( timer par_1, inout timer par_2 ) {
4765 temp := par_1; // error
4766 par_1 := par_2; // error
4767 par_2 := temp; // error
4774 MyAltstep( T1, T2 ); // good
4775 MyAltstep( T3, T4 ); // good
4776 MyAltstep( 3.8, 4.5 ); // error
4780 <RESULT IF_PASS COUNT 1>
4781 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?temp
4783 <RESULT IF_PASS COUNT 1>
4784 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1
4786 <RESULT IF_PASS COUNT 1>
4787 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2
4789 <RESULT IF_PASS COUNT 2>
4790 (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter
4792 <RESULT IF_PASS COUNT 5>
4795 <RESULT IF_PASS POSITIVE>
4796 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4802 .*---------------------------------------------------------------------*
4803 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: timer as non-mandatory parameter
4804 .*---------------------------------------------------------------------*
4806 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: timer as non-mandatory parameter>
4810 <MODULE TTCN ModuleA ModuleA.ttcn>
4812 type component MyCT {}
4813 altstep MyAltstep ( timer par_1 := 1.0, inout timer par_2 := 1.0) {
4818 <RESULT IF_PASS COUNT 2>
4819 (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter
4821 <RESULT IF_PASS COUNT 2>
4824 <RESULT IF_PASS POSITIVE>
4825 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4831 .*---------------------------------------------------------------------*
4832 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: timer
4833 .*---------------------------------------------------------------------*
4835 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: timer>
4839 <MODULE TTCN ModuleA ModuleA.ttcn>
4841 type component MyCT {}
4842 altstep MyCompAltstep ( timer par_1, inout timer par_2 ) runs on MyCT {
4845 temp := par_1; // error
4846 par_1 := par_2; // error
4847 par_2 := temp; // error
4850 function MyCompFunc () runs on MyCT {
4854 MyCompAltstep( T1, T2 ); // good
4855 MyCompAltstep( T3, T4 ); // good
4856 MyCompAltstep( 3.8, 4.5 ); // error
4860 <RESULT IF_PASS COUNT 1>
4861 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?temp
4863 <RESULT IF_PASS COUNT 1>
4864 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1
4866 <RESULT IF_PASS COUNT 1>
4867 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2
4869 <RESULT IF_PASS COUNT 2>
4870 (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter
4872 <RESULT IF_PASS COUNT 5>
4875 <RESULT IF_PASS POSITIVE>
4876 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
4882 .*---------------------------------------------------------------------*
4883 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: allowed in/out/inout
4884 .*---------------------------------------------------------------------*
4886 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: allowed in/out/inout>
4890 <MODULE TTCN ModuleA ModuleA.ttcn>
4892 type component MyCT {}
4895 boolean field2 optional
4897 type record address { integer field }
4898 testcase MyTestcase (
4899 integer par_11_1, // basic type
4900 in integer par_12_1,
4901 out integer par_13_1,
4902 inout integer par_14_1,
4904 octetstring par_11_2, // basic string type
4905 in octetstring par_12_2,
4906 out octetstring par_13_2,
4907 inout octetstring par_14_2,
4909 MySet par_21, // user-defined structured type
4914 address par_31, // address
4917 inout address par_34,
4919 template MySet par_41, // template
4920 in template MySet par_42,
4921 out template MySet par_43,
4922 inout template MySet par_44,
4924 MyCT par_51, // component type
4929 default par_71, // default
4932 inout default par_74 ) runs on MyCT {}
4935 <RESULT IF_PASS POSITIVE>
4936 (?im)\bnotify\b.+?Generating.+?code
4942 .*---------------------------------------------------------------------*
4943 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: allowed non-mandatory in/out/inout
4944 .*---------------------------------------------------------------------*
4946 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: allowed non-mandatory in/out/inout>
4950 <MODULE TTCN ModuleA ModuleA.ttcn>
4952 type port MyPort message { inout charstring; }
4955 boolean field2 optional
4957 type record address { integer field }
4958 type component MyCT {
4959 const integer comp_const_i := 0;
4960 var integer comp_var_i := 0;
4961 const octetstring comp_const_o := '00'O;
4962 var octetstring comp_var_o := '00'O;
4963 const MySet comp_const_set := {field1 := 1.0, field2 := true};
4964 var MySet comp_var_set := {field1 := 1.0, field2 := true};
4965 const address comp_const_address := {5};
4966 var address comp_var_address := {5};
4967 port MyPort comp_port;
4968 timer comp_timer := 1.0;
4970 testcase MyTestcase (
4971 integer par_11_1 := comp_const_i, // basic type
4972 in integer par_12_1 := comp_const_i,
4973 out integer par_13_1 := comp_var_i,
4974 inout integer par_14_1 := comp_var_i,
4976 octetstring par_11_2 := comp_const_o, // basic string type
4977 in octetstring par_12_2 := comp_const_o,
4978 out octetstring par_13_2 := comp_var_o,
4979 inout octetstring par_14_2 := comp_var_o,
4981 MySet par_21 := comp_const_set, // user-defined structured type
4982 in MySet par_22 := comp_const_set,
4983 out MySet par_23 := comp_var_set,
4984 inout MySet par_24 := comp_var_set,
4986 address par_31 := comp_const_address, // address
4987 in address par_32 := comp_const_address,
4988 out address par_33 := comp_var_address,
4989 inout address par_34 := comp_var_address ) runs on MyCT {}
4992 <RESULT IF_PASS POSITIVE>
4993 (?im)\bnotify\b.+?Generating.+?code
4999 .*---------------------------------------------------------------------*
5000 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: basic type
5001 .*---------------------------------------------------------------------*
5003 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: basic type>
5007 <MODULE TTCN ModuleA ModuleA.ttcn>
5009 type component MyCT {}
5010 testcase MyTestcase (
5011 integer par_1, // basic type
5014 inout integer par_4 ) runs on MyCT {
5015 var integer temp := par_1;
5022 var integer var_1 := 1;
5023 var integer var_2 := 2;
5024 var integer var_3 := 3;
5025 var integer var_4 := 4;
5026 var integer var_11, var_22, var_33, var_44;
5027 execute ( MyTestcase( var_1, var_2, var_3, var_4) ); // good
5028 execute ( MyTestcase( var_11, var_22, var_33, var_44) ); // good
5029 execute ( MyTestcase( 1, 2, var_3, var_4) ); // good
5030 execute ( MyTestcase( 1, 2, 3, 4) ); // error
5034 <RESULT IF_PASS COUNT 2>
5035 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
5037 <RESULT IF_PASS COUNT 1>
5038 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
5040 <RESULT IF_PASS COUNT 2>
5043 <RESULT IF_PASS POSITIVE>
5044 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5050 .*---------------------------------------------------------------------*
5051 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: basic string type
5052 .*---------------------------------------------------------------------*
5054 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: basic string type>
5058 <MODULE TTCN ModuleA ModuleA.ttcn>
5060 type component MyCT {}
5061 testcase MyTestcase (
5062 charstring par_1, // basic string type
5063 in charstring par_2,
5064 out charstring par_3,
5065 inout charstring par_4 ) runs on MyCT {
5066 var charstring temp := par_1;
5073 var charstring var_1 := "q";
5074 var charstring var_2 := "w";
5075 var charstring var_3 := "e";
5076 var charstring var_4 := "r";
5077 var charstring var_11, var_22, var_33, var_44;
5078 execute ( MyTestcase( var_1, var_2, var_3, var_4) ); // good
5079 execute ( MyTestcase( var_11, var_22, var_33, var_44) ); // good
5080 execute ( MyTestcase( "w", "e", var_3, var_4) ); // good
5081 execute ( MyTestcase( "q", "b", "5", "w") ); // error
5085 <RESULT IF_PASS COUNT 2>
5086 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
5088 <RESULT IF_PASS COUNT 1>
5089 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
5091 <RESULT IF_PASS COUNT 2>
5094 <RESULT IF_PASS POSITIVE>
5095 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5101 .*---------------------------------------------------------------------*
5102 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: user-defined type
5103 .*---------------------------------------------------------------------*
5105 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: user-defined type>
5109 <MODULE TTCN ModuleA ModuleA.ttcn>
5111 type component MyCT {}
5114 boolean field2 optional
5116 testcase MyTestcase (
5117 MySet par_1, // user-defined type
5120 inout MySet par_4 ) runs on MyCT {
5121 var MySet temp := { field1:=par_1.field1 }
5122 par_1.field1 := par_2.field1;
5123 par_2.field1 := par_3.field1;
5124 par_3.field1 := par_4.field1;
5125 par_4.field1 := temp.field1;
5128 var MySet var_1 := { field1:=1.3 };
5129 var MySet var_2 := { field1:=2.5 };
5130 var MySet var_3 := { field1:=3.1 };
5131 var MySet var_4 := { field1:=4.9 };
5132 var MySet var_11, var_22, var_33, var_44;
5133 execute ( MyTestcase(var_1,var_2,var_3,var_4) ); // good
5134 execute ( MyTestcase(var_11,var_22,var_33,var_44) ); // good
5135 execute ( MyTestcase( {field1:=1.2, field2:=true}, // good
5136 {field1:=2.5, field2:=true},
5139 execute ( MyTestcase( {field1:=1.2, field2:=true}, // error
5140 {field1:=2.5, field2:=true},
5141 {field1:=3.6, field2:=true},
5142 {field1:=4.1, field2:=true}) );
5146 <RESULT IF_PASS COUNT 2>
5147 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
5149 <RESULT IF_PASS COUNT 1>
5150 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
5152 <RESULT IF_PASS COUNT 2>
5155 <RESULT IF_PASS POSITIVE>
5156 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5162 .*---------------------------------------------------------------------*
5163 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: address type
5164 .*---------------------------------------------------------------------*
5166 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: address type>
5170 <MODULE TTCN ModuleA ModuleA.ttcn>
5172 type component MyCT {}
5173 type record address { integer field }
5174 testcase MyTestcase (
5175 address par_1, // address type
5178 inout address par_4 ) runs on MyCT {
5179 var address temp := { field:=par_1.field };
5180 par_1.field := par_2.field;
5181 par_2.field := par_3.field;
5182 par_3.field := par_4.field;
5183 par_4.field := temp.field;
5186 var address var_1 := { field:=1 };
5187 var address var_2 := { field:=2 };
5188 var address var_3 := { field:=3 };
5189 var address var_4 := { field:=4 };
5190 var address var_11, var_22, var_33, var_44;
5191 execute ( MyTestcase( {1}, {2}, var_3, var_4 ) ); // good
5192 execute ( MyTestcase( var_1, var_2, var_3, var_4 ) ); // good
5193 execute ( MyTestcase( var_11, var_22, var_33, var_44 ) ); // good
5194 execute ( MyTestcase( {1}, {2}, {3}, {4} ) ); // error
5198 <RESULT IF_PASS COUNT 2>
5199 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
5201 <RESULT IF_PASS COUNT 1>
5202 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
5204 <RESULT IF_PASS COUNT 2>
5207 <RESULT IF_PASS POSITIVE>
5208 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5214 .*---------------------------------------------------------------------*
5215 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: template
5216 .*---------------------------------------------------------------------*
5218 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: template>
5222 <MODULE TTCN ModuleA ModuleA.ttcn>
5224 type component MyCT {}
5225 testcase MyTestcase (
5226 template float par_1, // template
5227 in template float par_2,
5228 out template float par_3,
5229 inout template float par_4 ) runs on MyCT {
5231 temp := valueof ( par_1 );
5232 temp := valueof ( par_2 );
5233 temp := valueof ( par_3 );
5234 temp := valueof ( par_4 );
5241 var float var_1 := 1.3;
5242 var float var_2 := 2.5;
5243 var float var_3 := 3.1;
5244 var float var_4 := 4.9;
5245 var template float var_11, var_22, var_33, var_44;
5247 execute ( MyTestcase( 1.1, 2.8, var_33, var_44) ); // good
5248 execute ( MyTestcase( var_11, var_22, var_33, var_44) ); // good
5249 execute ( MyTestcase( var_1, var_2, var_3, var_4) ); // error
5250 execute ( MyTestcase( 1.1, 2.8, 3.53, 4.94) ); // error
5254 <RESULT IF_PASS COUNT 4>
5255 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
5257 <RESULT IF_PASS COUNT 2>
5258 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
5260 <RESULT IF_PASS COUNT 4>
5263 <RESULT IF_PASS POSITIVE>
5264 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5270 .*---------------------------------------------------------------------*
5271 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: component type
5272 .*---------------------------------------------------------------------*
5274 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: component type>
5278 <MODULE TTCN ModuleA ModuleA.ttcn>
5280 type component MyCT {}
5281 testcase MyTestcase (
5282 MyCT par_1, // component type
5285 inout MyCT par_4 ) runs on MyCT {
5286 var MyCT temp := par_1;
5293 execute ( MyTestcase( null, null, null, null) ); // good
5297 <RESULT IF_PASS COUNT 2>
5298 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
5300 <RESULT IF_PASS COUNT 1>
5301 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
5303 <RESULT IF_PASS COUNT 2>
5306 <RESULT IF_PASS POSITIVE>
5307 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5313 .*---------------------------------------------------------------------*
5314 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: default
5315 .*---------------------------------------------------------------------*
5317 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: default>
5321 <MODULE TTCN ModuleA ModuleA.ttcn>
5323 type component MyCT {}
5324 testcase MyTestcase (
5325 default par_1, // default type
5328 inout default par_4 ) runs on MyCT {
5329 var default temp := par_1;
5336 var default var_1, var_2, var_3, var_4;
5337 var default temp := null;
5338 execute ( MyTestcase( var_1, var_2, var_3, var_4 ) ); // good
5339 execute ( MyTestcase( temp, temp, temp, temp) ); // good
5340 execute ( MyTestcase( null, null, temp, temp) ); // good
5341 execute ( MyTestcase( null, null, null, null) ); // error
5345 <RESULT IF_PASS COUNT 2>
5346 (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter
5348 <RESULT IF_PASS COUNT 1>
5349 (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter
5351 <RESULT IF_PASS COUNT 2>
5354 <RESULT IF_PASS POSITIVE>
5355 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5361 .*---------------------------------------------------------------------*
5362 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: allowed in/out/inout
5363 .*---------------------------------------------------------------------*
5365 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: allowed in/out/inout>
5369 <MODULE TTCN ModuleA ModuleA.ttcn>
5371 type component MyCT {}
5374 boolean field2 optional
5376 type record address { integer field }
5377 signature MySigE(); // empty parameter list
5379 integer par_11_1, // basic type
5380 in integer par_12_1,
5381 out integer par_13_1,
5382 inout integer par_14_1,
5384 octetstring par_11_2, // basic string type
5385 in octetstring par_12_2,
5386 out octetstring par_13_2,
5387 inout octetstring par_14_2,
5389 MySet par_21, // user-defined structured type
5394 address par_31, // address
5397 inout address par_34,
5399 MyCT par_51, // component type
5402 inout MyCT par_54 );
5405 <RESULT IF_PASS POSITIVE>
5406 (?im)\bnotify\b.+?Generating.+?code
5412 .*---------------------------------------------------------------------*
5413 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: basic type
5414 .*---------------------------------------------------------------------*
5416 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: basic type>
5420 <MODULE TTCN ModuleA ModuleA.ttcn>
5423 integer par_1, // basic type
5426 inout integer par_4 );
5427 type port MyPortType procedure { inout MySig } with { extension "internal" }
5428 type component MyComp {
5429 port MyPortType MyPort;
5431 function MyFunc() runs on MyComp {
5432 var integer var_1 := 1;
5433 var integer var_2 := 2;
5434 var integer var_3 := 3;
5435 var integer var_4 := 4;
5436 var integer var_11, var_22, var_33, var_44;
5438 MyPort.call(MySig:{ var_1, var_2, var_3, var_4 }, 20E-3 + 20E-3) {
5439 [] MyPort.getreply {}
5441 MyPort.call(MySig:{ var_11, var_22, var_33, var_44 }, 20E-3 + 20E-3) {
5442 [] MyPort.getreply {}
5444 MyPort.call(MySig:{ 1, 2, var_3, var_4 }, 20E-3 + 20E-3) {
5445 [] MyPort.getreply {}
5447 MyPort.call(MySig:{ 1, 2, 3, 4 }, 20E-3 + 20E-3) {
5448 [] MyPort.getreply {}
5453 <RESULT IF_PASS POSITIVE>
5454 (?im)\bnotify\b.+?Generating.+?code
5460 .*---------------------------------------------------------------------*
5461 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: basic string type
5462 .*---------------------------------------------------------------------*
5464 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: basic string type>
5468 <MODULE TTCN ModuleA ModuleA.ttcn>
5471 charstring par_1, // basic string type
5472 in charstring par_2,
5473 out charstring par_3,
5474 inout charstring par_4 );
5475 type port MyPortType procedure { inout MySig } with { extension "internal" }
5476 type component MyComp {
5477 port MyPortType MyPort;
5479 function MyFunc() runs on MyComp {
5480 var charstring var_1 := "q";
5481 var charstring var_2 := "w";
5482 var charstring var_3 := "e";
5483 var charstring var_4 := "r";
5484 var charstring var_11, var_22, var_33, var_44;
5486 MyPort.call(MySig:{ var_1, var_2, var_3, var_4 }, 20E-3 + 20E-3) {
5487 [] MyPort.getreply {}
5489 MyPort.call(MySig:{ var_11, var_22, var_33, var_44 }, 20E-3 + 20E-3) {
5490 [] MyPort.getreply {}
5492 MyPort.call(MySig:{ "s", "z", var_3, var_4 }, 20E-3 + 20E-3) {
5493 [] MyPort.getreply {}
5495 MyPort.call(MySig:{ "p", "n", "c", "a" }, 20E-3 + 20E-3) {
5496 [] MyPort.getreply {}
5501 <RESULT IF_PASS POSITIVE>
5502 (?im)\bnotify\b.+?Generating.+?code
5508 .*---------------------------------------------------------------------*
5509 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: user-defined type
5510 .*---------------------------------------------------------------------*
5512 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: user-defined type>
5516 <MODULE TTCN ModuleA ModuleA.ttcn>
5523 MySet par_1, // user-defined type
5526 inout MySet par_4 );
5527 type port MyPortType procedure { inout MySig } with { extension "internal" }
5528 type component MyComp {
5529 port MyPortType MyPort;
5531 function MyFunc() runs on MyComp {
5532 var MySet var_1 := { field1:=1.3 };
5533 var MySet var_2 := { field1:=2.5 };
5534 var MySet var_3 := { field1:=3.1 };
5535 var MySet var_4 := { field1:=4.9 };
5536 var MySet var_11, var_22, var_33, var_44;
5538 MyPort.call(MySig:{ var_1, var_2, var_3, var_4 }, 20E-3 + 20E-3) {
5539 [] MyPort.getreply {}
5541 MyPort.call(MySig:{ var_11, var_22, var_33, var_44 }, 20E-3 + 20E-3) {
5542 [] MyPort.getreply {}
5544 MyPort.call(MySig:{ {field1:=1.2, field2:=true},
5545 {field1:=2.5, field2:=true},
5547 var_4 }, 20E-3 + 20E-3) {
5548 [] MyPort.getreply {}
5550 MyPort.call(MySig:{ {field1:=1.2, field2:=true},
5551 {field1:=2.5, field2:=true},
5552 {field1:=3.6, field2:=true},
5553 {field1:=4.1, field2:=true} }, 20E-3 + 20E-3) {
5554 [] MyPort.getreply {}
5559 <RESULT IF_PASS POSITIVE>
5560 (?im)\bnotify\b.+?Generating.+?code
5566 .*---------------------------------------------------------------------*
5567 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: address type
5568 .*---------------------------------------------------------------------*
5570 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: address type>
5574 <MODULE TTCN ModuleA ModuleA.ttcn>
5576 type record address { integer field }
5578 address par_1, // address type
5581 inout address par_4 );
5582 type port MyPortType procedure { inout MySig } with { extension "internal" }
5583 type component MyComp {
5584 port MyPortType MyPort;
5586 function MyFunc() runs on MyComp {
5587 var address var_1 := { field:=1 };
5588 var address var_2 := { field:=2 };
5589 var address var_3 := { field:=3 };
5590 var address var_4 := { field:=4 };
5591 var address var_11, var_22, var_33, var_44;
5593 MyPort.call(MySig:{ var_1, var_2, var_3, var_4 }, 20E-3 + 20E-3) {
5594 [] MyPort.getreply {}
5596 MyPort.call(MySig:{ var_11, var_22, var_33, var_44 }, 20E-3 + 20E-3) {
5597 [] MyPort.getreply {}
5599 MyPort.call(MySig:{ {2}, {5}, var_3, var_4 }, 20E-3 + 20E-3) {
5600 [] MyPort.getreply {}
5602 MyPort.call(MySig:{ {2}, {5}, {6}, {4} }, 20E-3 + 20E-3) {
5603 [] MyPort.getreply {}
5608 <RESULT IF_PASS POSITIVE>
5609 (?im)\bnotify\b.+?Generating.+?code
5615 .*---------------------------------------------------------------------*
5616 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: component type
5617 .*---------------------------------------------------------------------*
5619 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: component type>
5623 <MODULE TTCN ModuleA ModuleA.ttcn>
5625 type component MyCT {}
5627 MyCT par_1, // component type
5631 type port MyPortType procedure { inout MySig } with { extension "internal" }
5632 type component MyComp {
5633 port MyPortType MyPort;
5635 function MyFunc() runs on MyComp {
5636 var MyCT temp, var_1, var_2, var_3, var_4;
5637 temp := MyCT.create;
5639 MyPort.call(MySig:{ var_1, var_2, var_3, var_4 }, 20E-3 + 20E-3) {
5640 [] MyPort.getreply {}
5642 MyPort.call(MySig:{ temp, temp, temp, temp }, 20E-3 + 20E-3) {
5643 [] MyPort.getreply {}
5645 MyPort.call(MySig:{ MyCT.create, MyCT.create, temp, temp }, 20E-3 + 20E-3) {
5646 [] MyPort.getreply {}
5648 MyPort.call(MySig:{ MyCT.create, MyCT.create, MyCT.create, MyCT.create }, 20E-3 + 20E-3) {
5649 [] MyPort.getreply {}
5654 <RESULT IF_PASS POSITIVE>
5655 (?im)\bnotify\b.+?Generating.+?code
5661 .*---------------------------------------------------------------------*
5662 :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: special parameter
5663 .*---------------------------------------------------------------------*
5665 <TC - TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: special parameter>
5669 <MODULE TTCN ModuleA ModuleA.ttcn>
5672 integer par_1, // basic type
5675 inout integer par_4 );
5676 type port MyPortType procedure { inout MySig } with { extension "internal" }
5677 type component MyComp {
5678 port MyPortType MyPort;
5680 function MyFunc() runs on MyComp {
5681 MyPort.call(MySig:{ -, 2, 3, 4 }, 20E-3 + 20E-3) { // good
5684 MyPort.call(MySig:{ 1, -, 3, 4 }, 20E-3 + 20E-3) { // good
5687 MyPort.call(MySig:{ 1, 2, -, 4 }, 20E-3 + 20E-3) { // good
5690 MyPort.call(MySig:{ 1, 2, 3, - }, 20E-3 + 20E-3) { // error
5696 <RESULT IF_PASS COUNT 1>
5697 (?im)\berror\b.+?Signature.+?incomplete.+?inout.+?parameter.+?par_4.+?missing
5699 <RESULT IF_PASS COUNT >
5702 <RESULT IF_PASS POSITIVE>
5703 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5710 .*---------------------------------------------------------------------*
5711 :h3. group parametrization test 1
5712 .*---------------------------------------------------------------------*
5714 <TC - group parametrization test 1 >
5717 <MODULE TTCN ModuleA ModuleA.ttcn>
5724 <RESULT IF_FAIL COUNT 1>
5725 (?im)\berror\b.+syntax error
5730 .*---------------------------------------------------------------------*
5731 :h3. group parametrization test 2
5732 .*---------------------------------------------------------------------*
5734 <TC - group parametrization test 2 >
5737 <MODULE TTCN ModuleA ModuleA.ttcn>
5744 <RESULT IF_FAIL COUNT 1>
5745 (?im)\berror\b.+syntax error
5750 .*---------------------------------------------------------------------*
5751 :h3.TTCN-3::FunctionReference invalid parametrization of type
5752 .*---------------------------------------------------------------------*
5754 <TC - TTCN-3::FunctionReference invalid parametrization of type>
5757 <MODULE TTCN ModuleA ModuleA.ttcn>
5759 type function fntype(in integer i);
5765 <RESULT IF_FAIL COUNT 1>
5768 <RESULT IF_FAIL POSITIVE>
5769 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5774 .*---------------------------------------------------------------------*
5775 :h3.TTCN-3::FunctionReference invalid parametrization of type 2
5776 .*---------------------------------------------------------------------*
5778 <TC - TTCN-3::FunctionReference invalid parametrization of type 2>
5781 <MODULE TTCN ModuleA ModuleA.ttcn>
5783 type function(in integer i) fntype;
5788 <RESULT IF_FAIL COUNT 1>
5791 <RESULT IF_FAIL POSITIVE>
5792 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5797 .*---------------------------------------------------------------------*
5798 :h3.TTCN-3::FunctionReference invalid parametrization of variable
5799 .*---------------------------------------------------------------------*
5801 <TC - TTCN-3::FunctionReference invalid parametrization of variable>
5804 <MODULE TTCN ModuleA ModuleA.ttcn>
5806 type function fntype(in integer i);
5807 function fn(in integer i) { }
5809 var fntype f := refers(fn);
5814 <RESULT IF_FAIL COUNT 1>
5817 <RESULT IF_FAIL POSITIVE>
5818 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5823 .*---------------------------------------------------------------------*
5824 :h3.TTCN-3::FunctionReference invalid parametrization of derefers
5825 .*---------------------------------------------------------------------*
5827 <TC - TTCN-3::FunctionReference invalid parametrization of derefers>
5830 <MODULE TTCN ModuleA ModuleA.ttcn>
5832 type function fntype(in integer i);
5833 function fn(in integer i) { }
5835 var fntype f := refers(fn);
5836 execute(derefers(f));
5840 <RESULT IF_FAIL COUNT 1>
5843 <RESULT IF_FAIL POSITIVE>
5844 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5849 .*---------------------------------------------------------------------*
5850 :h3.TTCN-3::FunctionReference invalid parametrization of derefers 2
5851 .*---------------------------------------------------------------------*
5853 <TC - TTCN-3::FunctionReference invalid parametrization of derefers 2>
5856 <MODULE TTCN ModuleA ModuleA.ttcn>
5858 function fn(in integer i) { }
5860 execute(derefers(refers(fn)));
5864 <RESULT IF_FAIL COUNT 1>
5867 <RESULT IF_FAIL POSITIVE>
5868 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5873 .*---------------------------------------------------------------------*
5874 :h3.TTCN-3::FunctionReference invalid parametrization of derefers 3
5875 .*---------------------------------------------------------------------*
5877 <TC - TTCN-3::FunctionReference invalid parametrization of derefers 3>
5880 <MODULE TTCN ModuleA ModuleA.ttcn>
5882 type component my_component{};
5883 function fn(in integer i) { }
5885 var my_component comp_var := my_component.create;
5886 comp_var.start(derefers(refers(fn)));
5890 <RESULT IF_FAIL COUNT 1>
5893 <RESULT IF_FAIL POSITIVE>
5894 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5900 .*---------------------------------------------------------------------*
5901 :h3.TTCN-3::FunctionReference invalid parametrization of derefers 4
5902 .*---------------------------------------------------------------------*
5904 <TC - TTCN-3::FunctionReference invalid parametrization of derefers 4>
5907 <MODULE TTCN ModuleA ModuleA.ttcn>
5909 function fn(in integer i) { }
5911 execute(derefers(null));
5915 <RESULT IF_FAIL COUNT 1>
5918 <RESULT IF_FAIL POSITIVE>
5919 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5924 .*---------------------------------------------------------------------*
5925 :h3.TTCN-3::FunctionReference invalid parametrization of derefers 5
5926 .*---------------------------------------------------------------------*
5928 <TC - TTCN-3::FunctionReference invalid parametrization of derefers 5>
5931 <MODULE TTCN ModuleA ModuleA.ttcn>
5933 type component my_component{};
5934 function fn(in integer i) { }
5936 var my_component comp_var := my_component.create;
5937 comp_var.start(derefers(null));
5941 <RESULT IF_FAIL COUNT 1>
5944 <RESULT IF_FAIL POSITIVE>
5945 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
5950 .*---------------------------------------------------------------------*
5951 :h3.TTCN-3::Big integer parameters
5952 .*---------------------------------------------------------------------*
5954 <TC - TTCN-3::Big integer parameters>
5958 <MODULE TTCN ModuleA ModuleA.ttcn>
5960 type component my_component { }
5961 function fn(in integer i, in integer j) runs on my_component { }
5962 testcase tc(in integer i) runs on my_component { fn(1234567891011121314151617181920, i) }
5964 execute(tc(1234567891011121314151617181920))
5968 <RESULT IF_PASS POSITIVE>
5969 (?im)\bnotify\b.+?Generating.+?code
5975 .*---------------------------------------------------------------------*
5976 :h3.TTCN-3::Parameterised template reference without parameter list1
5977 .*---------------------------------------------------------------------*
5979 <TC - TTCN-3::Parameterised template reference without parameter list1>
5983 <MODULE TTCN ModuleA ModuleA.ttcn>
5985 type record my_type {
5989 template my_type t_orig (in integer pl_1 := 0, in integer pl_2 := 0)
5996 var template my_type X1 := t_orig(1,2);
5997 var template my_type X2 := t_orig();
5998 var template my_type X3 := t_orig;
6002 <RESULT IF_PASS POSITIVE>
6003 (?im)\bnotify\b.+?Generating.+?code
6009 .*---------------------------------------------------------------------*
6010 :h3.TTCN-3::Parameterised template reference without parameter list2
6011 .*---------------------------------------------------------------------*
6013 <TC - TTCN-3::Parameterised template reference without parameter list2>
6017 <MODULE TTCN ModuleA ModuleA.ttcn>
6019 type record my_type {
6023 template my_type t_orig (in integer pl_1 := 0, in integer pl_2)
6030 var template my_type X1 := t_orig(1,2);
6031 var template my_type X2 := t_orig();
6032 var template my_type X3 := t_orig;
6036 <RESULT IF_PASS COUNT 1>
6037 (?im)\berror\b.+?Too.+?few.+?parameters.+?2.+?was.+?expected.+?instead.+?of.+?0
6039 <RESULT IF_PASS COUNT 1>
6040 (?im)\berror\b.+?Reference.+?to.+?parameterized.+?definition.+?without.+?actual.+?parameter.+?list
6042 <RESULT IF_PASS POSITIVE>
6043 (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b
6049 .*---------------------------------------------------------------------*
6051 .*---------------------------------------------------------------------*
6053 :li D='ASN.1'.Abstract Syntax Notation 1
6054 :li D='EDML'.Ericsson Document Markup Language
6055 :li D='SA'.Semantic Analyser
6056 :li D='TTCN-3'.Test and Test Control Notation version 3
6059 .*---------------------------------------------------------------------*
6061 .*---------------------------------------------------------------------*
6063 :li D='[1]'.3/ETH/RUS-2003:0087 Uen
6064 :nl.Requirement Specification for TITAN's TTCN-3 Semantic Analyser
6065 :li D='[2]'.1/174 02-FCPCA 101 42 Uen
6066 :nl.Statement of Compliance for TITAN project
6067 :li D='[3]'.ETSI ES 201 873-1, v3.0.0 Mockup v1 (2004-03):
6068 :nl.Testing and Test Control Notation version 3.,
6069 :nl.Part 1: TTCN-3 Core Language
6072 .*---------------------------------------------------------------------*
6074 .*---------------------------------------------------------------------*
6076 :li D='TITAN'.Ericsson's TTCN-3 Test Environment