.****************************************************************************** .* Copyright (c) 2000-2014 Ericsson Telecom AB .* All rights reserved. This program and the accompanying materials .* are made available under the terms of the Eclipse Public License v1.0 .* which accompanies this distribution, and is available at .* http://www.eclipse.org/legal/epl-v10.html .******************************************************************************/ :text. :lang eng. .* EDML webpage: http://cpi.ericsson.se/dwaxe/ .* EDML2PDF converter: http://dwaxe.ericsson.se/x2pdf .* EDML user guide: http://www.lmc.ericsson.se/~lmcmarg/isit/edml_ug.html .* Document header information :docname.Test Description :docno.15/152 91-CRL 113 200/3 Uen :rev.A :date.2015-04-27 :prep.ETH/XZ Jeno Balasko :appr.ETH/XZ (Gyula Koos) :checked.ETHGRY :title.Test description of the TTCN-3 Semantic Analyzer: Parameters :contents level=2. .*---------------------------------------------------------------------* :h1.Introduction .*---------------------------------------------------------------------* .*---------------------------------------------------------------------* :h2.Revision history .*---------------------------------------------------------------------* :xmp tab=2. REV DATE PREPARED CHANGE ________________________________________________________ PA1 2005-02-19 ETIBHRA New document for TITAN R6 A 2005-03-18 ETIBHRA Approved after review B 2006-07-31 EKRISZA Updates for TITAN R6E C 2007-03-06 EJNOSZA Updates for TITAN R7A (expected error messages) D 2008-10-01 EFERKOV Large integers PE1 2010-03-11 EKRISZA added tests for the fix of TR HL63421 E 2010-07-02 EKRISZA version correction. A 2011-12-12 EKRISZA Updated for release A 2012-06-27 EFERKOV Updated for release A 2013-01-17 EKRIPND Updated for release :exmp. .*---------------------------------------------------------------------* :h2.Purpose .*---------------------------------------------------------------------* The purpose of this Test Description is to define and describe the function test activity for the Semantic Analyser functionality of the TTCN-3 compiler: :nl.SA-1/4: Parameters. :p.The specification of the test cases can be found in this document. .*---------------------------------------------------------------------* :h1.Test environment .*---------------------------------------------------------------------* .*---------------------------------------------------------------------* :h2.Hardware .*---------------------------------------------------------------------* No specific hardware requirement. .*---------------------------------------------------------------------* :h2.Software .*---------------------------------------------------------------------* Tests shall be carried out on the following platforms: :list. :li D='1.'.Solaris 8 (Sun OS 5.8) (gcc 3.0.4) :li D='2.'.SUSE Linux Enterprise server 8 (2.4.19-4GB) (gcc 3.2) :li D='3.'.CYGWIN_NT-5.0 (Cygwin DLL: 1.5.12) on Windows 2000 (gcc 3.3.3) :elist. .*---------------------------------------------------------------------* :h2.Configuration .*---------------------------------------------------------------------* The test environment had been setup in CVS. The tester program is stored in: :nl.TTCNv3/function_test/Tools/SAtester.pl :nl.Test cases are stored with extension .script in the directory: :nl.TTCNv3/function_test/Semantic_Analyser/ .*---------------------------------------------------------------------* :h2.Installation .*---------------------------------------------------------------------* Install proper TITAN binaries on the used platforms and make sure that your environment settings are correct: :list. :li D='1.'.TTCN3_DIR is set :li D='2.'.$TTCN3_DIR/bin is added to the PATH variable :li D='3.'.$TTCN3_DIR/lib is added to the LD_LIBRARY_PATH variable :li D='4.'.Perl 5.6.0 or higher is available on the platform :li D='5.'.Create a symlink to your Perl binary into the directory where the test cases are stored: :nl.ln -s perl :elist. .*---------------------------------------------------------------------* :h2.Test Tools .*---------------------------------------------------------------------* A tester program had been written in Perl especially for the Semantic Analyser tests. For the list of command line parameters, type 'SAtester.pl -help', for the complete documentation, type 'SAtester.pl -doc'. :p.Test cases are specified in the Test Description documents in EDML format. The tester program parses these files and generates the TTCN-3/ASN.1 modules, then calls the compiler to compile them. The result printout is then matched against different patterns to be able to set the verdict. Test cases contain not only the source modules, but the patterns as well. :p.The tester program allows one-by-one execution of test cases and batched execution as well. :p.NOTE: the tester program requires Perl 5.6.0 or higher. :np. .*---------------------------------------------------------------------* :h1.Test cases .*---------------------------------------------------------------------* .*---------------------------------------------------------------------* :h2.Parameterization is not allowed .*---------------------------------------------------------------------* This test case group covers the requirement SA-4/1. :p. Explanation: :nl. Parameterization is not allowed for the following specific language elements: const, var, timer, control, group and import. :p. Test strategy: :space 1. :xmp tab=0. Hierarchy of scope units Abbreviations: MDP: Module Definitons Part MCP: Module Control Part CT : Component Type FUN: Function without runs on-clause ALT: Altstep without runs on-clause FWR: Function with runs on-clause AWR: Altstep with runs on-clause TC : Testcase with runs on-clause and optional system-clause BS : Block of statements (within a compound statement) EBS: Embedded block of statements (within a compound statement) :exmp. :space 2. :xmp tab=0. _____________________________________________ | | 0. _____| MDP |_______ | |_____________________________________________| | __|__ __|__ __|__ __|__ | | | | | | | | 1. | MCP | ________| CT |________ | FUN | | ALT | |_____| | |_____| | |_____| |_____| | __|__ __|__ __|__ | | | | | | | | | | | 2. | | FWR | | AWR | | TC | | | | |_____| |_____| |_____| | | __|__ __|__ __|__ __|__ __|__ __|__ | | | | | | | | | | | | 3. | BS | | BS | | BS | | BS | | BS | | BS | |_____| |_____| |_____| |_____| |_____| |_____| __|__ __|__ __|__ __|__ __|__ __|__ | | | | | | | | | | | | 4. | EBS | | EBS | | EBS | | EBS | | EBS | | EBS | |_____| |_____| |_____| |_____| |_____| |_____| | | | | | | | | | | | | :exmp. :np. :xmp tab=1. Test cases are based on TTCN-3 according to the followings: - We have to check the "const", "var" and "timer" elements. - We checked this elements where we can use firstly in the scope hierarchy and unnecessary to check on the lower levels. Example: The const is checked only in the MDP because another bubbles are on the lower levels. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Definitions part: const .*---------------------------------------------------------------------* :xmp tab=0. Definitions part: const> module ModuleA { const integer C := 1; const integer CC := C(0); } (?im)\berror\b.+?referenced.+?C.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Control part: var .*---------------------------------------------------------------------* :xmp tab=0. Control part: var> module ModuleA { control { var integer X := 1; var integer XX := X(0); } } (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Component type: var .*---------------------------------------------------------------------* :p. NOTE: :nl.The implementation does not support the variable initialized with another variable in the component type (but it would be possible according to TTCN-3 specification ). :xmp tab=0. Component type: var> module ModuleA { type component MyCT { var integer X := 1; var integer XX := X(0); } } (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters (?im)\berror\b.+?Reference.+?static.+?value.+?was.+?expected (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Component type--Function: var .*---------------------------------------------------------------------* :xmp tab=0. Component type--Function: var> module ModuleA { type component MyCT { var integer X := 1; } function MyCompFunc() runs on MyCT { var integer XX := X(0); } } (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Component type--Altstep: var .*---------------------------------------------------------------------* :xmp tab=0. Component type--Altstep: var> module ModuleA { type component MyCT { var integer X := 1; } altstep MyCompALtstep() runs on MyCT { var integer XX := X(0); [else] {} } } (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Component type--Testcase: var .*---------------------------------------------------------------------* :xmp tab=0. Component type--Testcase: var> module ModuleA { type component MyCT { var integer X := 1; } testcase MyTestcase() runs on MyCT { var integer XX := X(0); } } (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Function: var .*---------------------------------------------------------------------* :xmp tab=0. Function: var> module ModuleA { function MyFunc() { var integer X := 1; var integer XX := X(0); } } (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Altstep: var .*---------------------------------------------------------------------* :xmp tab=0. Altstep: var> module ModuleA { altstep MyAltstep(timer T) { var integer X := 1; [X(0)>2] T.timeout {}; [else] {}; } } (?im)\berror\b.+?referenced.+?X.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Control part: timer .*---------------------------------------------------------------------* :xmp tab=0. Control part: timer> module ModuleA { function MyFunc( timer t ) {} control { timer T := 1.2; MyFunc(T(0)); } } (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Component type--Function: timer .*---------------------------------------------------------------------* :xmp tab=0. Component type--Function: timer> module ModuleA { function MyFunc( timer t ) {} type component MyCT { timer T := 1.2; } function MyCompFunc() runs on MyCT { MyFunc(T(0)); } } (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Component type--Altstep: timer .*---------------------------------------------------------------------* :xmp tab=0. Component type--Altstep: timer> module ModuleA { function MyFunc( timer t ) {} type component MyCT { timer T := 1.2; } altstep MyCompAltstep() runs on MyCT { [else] { MyFunc(T(0)); }; } } (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Component type--Testcase: timer .*---------------------------------------------------------------------* :xmp tab=0. Component type--Testcase: timer> module ModuleA { function MyFunc( timer t ) {} type component MyCT { timer T := 1.2; } testcase MyTestcase() runs on MyCT { MyFunc(T(0)); } } (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Function: timer .*---------------------------------------------------------------------* :xmp tab=0. Function: timer> module ModuleA { function MyFunc_1( timer t ) {} function MyFunc_2() { timer T := 1.3; MyFunc_1(T(0)); } } (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParameterizationNotAllowed->Altstep: timer .*---------------------------------------------------------------------* :xmp tab=0. Altstep: timer> module ModuleA { function MyFunc( timer t ) {} altstep MyAltstep(timer T) { [else] { MyFunc(T(0)); }; } } (?im)\berror\b.+?referenced.+?T.+?cannot.+?have.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. :np. .*---------------------------------------------------------------------* :h2.Not allowed type in a formal/actual parameter list .*---------------------------------------------------------------------* This test case group covers the requirement SA-4/2. :p. Explanation: :nl. Some specific types are not allowed to be used in the parameter list of a language element. :list. :li d='modulepar:' template, component type, port type, default and timer are not allowed according to the TTCN-3 specification :nl. ( NotAllowedTypeInParameterList->Modulepar ) :nl. NOTE: the component type and default are supported in the implementation and not allowed the empty parameter list; :li d='type:' any type is not currently supported in the implementation :nl. ( NotAllowedTypeInParameterList->Type ) :nl. NOTE: all basic types, all user-defined types and address type are allowed according to the TTCN-3 specification; :li d='template:' component type, port type, default and timer are not allowed :nl. ( NotAllowedTypeInParameterList->Template ) :nl. NOTE: the component type and default are supported in the implementation; :li d='testcase:' component type, port type, default and timer are not allowed :nl. ( NotAllowedTypeInParameterList->Testcase ) :nl. NOTE: the component type and default are supported in the implementation; :li d='signature:' template, port type, default and timer are not allowed :nl. ( NotAllowedTypeInParameterList->Signature ); :elist :p. Test strategy: :nl. We made a test for each type of values that is allowed to appear in the formal/actual parameter lists of all language elements. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Modulepar: allowed types .*---------------------------------------------------------------------* :xmp tab=0. Modulepar: allowed types> module ModuleA { type record MyRec { charstring field } type record address { integer filed } //modulepar not allowed types are tested : in TTCN3_SA_ttcn3adhoc.script (modulepar invalid simple type, // modulepar invalid compound type, modulepar invalid list, modulepar invalid type: circular type definition) modulepar { boolean MyBool := false; integer MyInt1, MyInt2; MyRec myrec; address MyPC := { 23475 }; template integer MyTemp := 1; } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Modulepar: empty .*---------------------------------------------------------------------* :xmp tab=0. Modulepar: empty> module ModuleA { modulepar {} } (?im)\berror\b.+?syntax.+?error (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Modulepar: port type .*---------------------------------------------------------------------* :xmp tab=0. Modulepar: port type> module ModuleA { type port MyPort message { inout charstring; } modulepar { MyPort port_1 } } (?im)\berror\b.+?module.+?parameter.+?cannot.+?port (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Modulepar: timer .*---------------------------------------------------------------------* :xmp tab=0. Modulepar: timer> module ModuleA { modulepar { timer T := 1.2 } } (?im)\berror\b.+?syntax.+?error (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Types .*---------------------------------------------------------------------* :xmp tab=0. Types> module ModuleA { type record rtype (integer p) {integer i (p .. p+10)} const rtype(0.0) r1 := {i :=1} const rtype('0'B) r2 := {i :=1} const rtype('0'H) r3 := {i :=1} const rtype('00'O) r4 := {i :=1} const rtype("0") r5 := {i :=1} type set stype (integer p) {integer i (p .. p+10)} const stype(0.0) s1 := {i :=1} const stype('0'B) s2 := {i :=1} const stype('0'H) s3 := {i :=1} const stype('00'O) s4 := {i :=1} const stype("0") s5 := {i :=1} } (?im)\berror\b.+?not.+?supported :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Template: allowed types .*---------------------------------------------------------------------* :xmp tab=0. Template: allowed types> module ModuleA { type component MyCT {} type set MySet { integer field1, boolean field2 optional } type record address { integer filed } type record MyRec { float field1 optional, charstring field2, MySet field3, address field4, MyCT field5, default field6 } template MyRec MyTempE := {?,?,?,?,?,?} // empty parameter list template MyRec MyTemp ( charstring par_1, address par_2, MyCT par_3, default par_4, MySet par_5, template float par_6 ) := { field1 := par_6, field2 := par_1, field3 := par_5, field4 := par_2, field5 := par_3, field6 := par_4 } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Template: port type .*---------------------------------------------------------------------* :xmp tab=0. Template: port type> module ModuleA { type port MyPort message { inout charstring; } type set MySet { integer field1, boolean field2 optional } template MySet MyTemp ( MyPort par_1 ) := { field1 := ?, field2 := ? } } (?im)\berror\b.+?template.+?cannot.+?have.+?port (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Template: timer .*---------------------------------------------------------------------* :xmp tab=0. Template: timer> module ModuleA { type set MySet { integer field1, boolean field2 optional } template MySet MyTemp ( timer par_1 ) := { field1 := ?, field2 := ? } } (?im)\berror\b.+?syntax.+?error (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Function: allowed types .*---------------------------------------------------------------------* :xmp tab=0. Function: allowed types> module ModuleA { type port MyPort message { inout charstring; } type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer filed } function MyFuncE() {} // empty parameter list function MyFunc ( integer par_1, MySet par_2, address par_3, template MySet par_4, MyCT par_5, MyPort par_6, default par_7, timer par_8 ) {} function MyCompFuncE() {} // empty parameter list function MyCompFunc ( integer par_1, MySet par_2, address par_3, template MySet par_4, MyCT par_5, MyPort par_6, default par_7, timer par_8 ) runs on MyCT {} external function MyExtFuncE(); // empty parameter list external function MyExtFunc ( integer par_1, MySet par_2, address par_3, template MySet par_4, MyCT par_5, MyPort par_6, default par_7, timer par_8 ); } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Altstep: allowed types .*---------------------------------------------------------------------* :xmp tab=0. Altstep: allowed types> module ModuleA { type port MyPort message { inout charstring; } type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer filed } altstep MyAltstepE() { [else]{} } // empty parameter list altstep MyAltstep ( integer par_1, MySet par_2, address par_3, template MySet par_4, MyCT par_5, MyPort par_6, default par_7, timer par_8 ) { [else] {} } altstep MyCompAltstepE() { [else]{} } // empty parameter list altstep MyCompAltstep ( integer par_1, MySet par_2, address par_3, template MySet par_4, MyCT par_5, MyPort par_6, default par_7, timer par_8 ) runs on MyCT { [else] {} } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Testcase: allowed types .*---------------------------------------------------------------------* :xmp tab=0. Testcase: allowed types> module ModuleA { type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer filed } testcase MyTestcaseE() runs on MyCT {} // empty parameter list testcase MyTestcase ( integer par_1, MySet par_2, address par_3, template MySet par_4, MyCT par_5, default par_6 ) runs on MyCT {} } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Testcase: port type .*---------------------------------------------------------------------* :xmp tab=0. Testcase: port type> module ModuleA { type port MyPort message { inout charstring; } type component MyCT {} testcase MyTestcase( MyPort par_1 ) runs on MyCT {} } (?im)\berror\b.+?testcase.+?cannot.+?have.+?port (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Testcase: timer .*---------------------------------------------------------------------* :xmp tab=0. Testcase: timer> module ModuleA { type component MyCT {} testcase MyTestcase( timer par_1 ) runs on MyCT {} } (?im)\berror\b.+?syntax.+?error (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Signature: allowed types .*---------------------------------------------------------------------* :xmp tab=0. Signature: allowed types> module ModuleA { type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer filed } signature MySigE(); // empty parameter list signature MySig ( integer par_1, MySet par_2, address par_3, MyCT par_5 ); } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Signature: template .*---------------------------------------------------------------------* :xmp tab=0. Signature: template> module ModuleA { signature MySig( template integer par_1 ); } (?im)\berror\b.+?syntax.+?error (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Signature: port type .*---------------------------------------------------------------------* :xmp tab=0. Signature: port type> module ModuleA { type port MyPort message { inout charstring; } signature MySig( MyPort par_1 ); } (?im)\berror\b.+?Port.+?cannot.+?be.+?signature (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Signature: default .*---------------------------------------------------------------------* :xmp tab=0. Signature: default> module ModuleA { signature MySig( default par_1 ); } (?im)\berror\b.+?Default.+?cannot.+?be.+?signature (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::NotAllowedTypeInParameterList->Signature: timer .*---------------------------------------------------------------------* :xmp tab=0. Signature: timer> module ModuleA { signature MySig( timer par_1 ); } (?im)\berror\b.+?syntax.+?error (?is)\berror: :exmp. :np. .*---------------------------------------------------------------------* :h2.Mismatch in actual and formal parameter list .*---------------------------------------------------------------------* This test case group covers the requirement SA-4/3. :p. Explanation: :nl. SA shall detect if there is a mismatch between the formal and the actual parameter list. :p. - We can use the formal and the actual parameter list according to the TTCN-3 specification on the following language elements: :nl. type, template, function, altstep, testcase and signature. :nl. NOTE: types are not currently supported in the implementation. :p. - In the actual and the corresponding formal parameter list: :list. :li d='number:'. shall be the same as the number of elements; :li d='order:'. shall be the same as the order of elements; :li d='types:'. shall be compatible with the types of elements. :elist. :space 1. :p. Test strategy: :list. :li d='number:'. we made a test for each language elements; :li d='order and type compatibility:'. the type compatibility checking covers the order checking, therefore the order checking is not necessary (see the type compatibility checking in the requirement SA-5/2); :elist. .*---------------------------------------------------------------------* :h3.TTCN-3::MismachActualFormalParameterList->Types: number .*---------------------------------------------------------------------* :xmp tab=0. Types: number> module ModuleA { type record rtype (integer p, boolean b) {integer i (p .. p+10), boolean b (b)} const rtype() r1 := {1, true} const rtype(1) r2 := {1, true} const rtype(1, true, 2) r3 := {1, true} type set stype (integer p, boolean b) {integer i (p .. p+10), boolean b (b)} const stype() s1 := {1, true} const stype(1) s2 := {1, true} const stype(1, true, 2) s3 := {1, true} } (?im)\berror\b.+?not.+?supported :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::MismachActualFormalParameterList->Template: number .*---------------------------------------------------------------------* :xmp tab=0. Template: number> module ModuleA { type record MyRec { integer field1, charstring field2, boolean field3 } template MyRec MyTemp( charstring par_1, boolean par_2, integer par_3 ) := { field1 := par_3, field2 := par_1, field3 := par_2 } template MyRec MyTemp2( charstring par_1 := "r", boolean par_2):= { field1 := 6, field2 := par_1, field3 := par_2 } template MyRec MyTemp3(charstring par_1 := "r", boolean par_2:= false, integer par_3:=6):= { field1 := par_3, field2 := par_1, field3 := par_2 } function MyFunc( template MyRec mytemp ) {} control { MyFunc(MyTemp("r",true,6)); // good MyFunc(MyTemp("r",true)); // too few parameters MyFunc(MyTemp("r",true,6,1.3)); // too many parameters MyFunc(MyTemp2(true)); // too few parameters MyFunc(MyTemp3("r",true,6,1.3)); // too many parameters MyFunc(MyTemp3(-,true,6,1.3)); // too many parameters MyFunc(MyTemp3("r",true,6,-)); // too many parameters } } (?im)\berror\b.+?Too.+?few.+?parameters (?im)\berror\b.+?Too.+?many.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::MismachActualFormalParameterList->Function: number .*---------------------------------------------------------------------* :xmp tab=0. Function: number> module ModuleA { function MyFunc( integer par_1, charstring par_2, boolean par_3 ) {} function MyFunc2( integer par_1 := 6, charstring par_2){} function MyFunc3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false){} control { MyFunc(6,"r",true); // good MyFunc(6,"r"); // too few parameters MyFunc(56,"r",true,1.3); // too many parameters MyFunc2("r"); // too few parameters MyFunc3(6,"r",true,1.3); // too many parameters MyFunc3(-,"r",true,1.3); // too many parameters MyFunc3(6,"r",true,-); // too many parameters } } (?im)\berror\b.+?Too.+?few.+?parameters (?im)\berror\b.+?Too.+?many.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::MismachActualFormalParameterList->Function_runs_on: number .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: number> module ModuleA { type component MyCT {} function MyFunc( integer par_1, charstring par_2, boolean par_3 ) runs on MyCT {} function MyFunc2( integer par_1 := 6, charstring par_2) runs on MyCT {} function MyFunc3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false) runs on MyCT {} testcase MyTemp() runs on MyCT { MyFunc(6,"r",true); // good MyFunc(6,"r"); // too few parameters MyFunc(56,"r",true,1.3); // too many parameters MyFunc2("r"); // too few parameters MyFunc3(6,"r",true,1.3); // too many parameters MyFunc3(-,"r",true,1.3); // too many parameters MyFunc3(6,"r",true,-); // too many parameters } } (?im)\berror\b.+?Too.+?few.+?parameters (?im)\berror\b.+?Too.+?many.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::MismachActualFormalParameterList->External Function: number .*---------------------------------------------------------------------* :xmp tab=0. External Function: number> module ModuleA { type component MyCT {} external function MyExtFunc( integer par_1, charstring par_2, boolean par_3 ); external function MyExtFunc2( integer par_1 := 6, charstring par_2); external function MyExtFunc3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false); control { MyExtFunc(6,"r",true); // good MyExtFunc(6,"r"); // too few parameters MyExtFunc(56,"r",true,1.3); // too many parameters MyExtFunc2("r"); // too few parameters MyExtFunc3(6,"r",true,1.3); // too many parameters MyExtFunc3(-,"r",true,1.3); // too many parameters MyExtFunc3(6,"r",true,-); // too many parameters } } (?im)\berror\b.+?Too.+?few.+?parameters (?im)\berror\b.+?Too.+?many.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::MismachActualFormalParameterList->Altstep: number .*---------------------------------------------------------------------* :xmp tab=0. Altstep: number> module ModuleA { altstep MyAltstep( integer par_1, charstring par_2, boolean par_3 ) { [else] {} } altstep MyAltstep2( integer par_1 := 6, charstring par_2) { [else] {} } altstep MyAltstep3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false) { [else] {} } control { MyAltstep(6,"r",true); // good MyAltstep(6,"r"); // too few parameters MyAltstep(56,"r",true,1.3); // too many parameters MyAltstep2("r"); // too few parameters MyAltstep3(6,"r",true,1.3); // too many parameters MyAltstep3(-,"r",true,1.3); // too many parameters MyAltstep3(6,"r",true,-); // too many parameters } } (?im)\berror\b.+?Too.+?few.+?parameters (?im)\berror\b.+?Too.+?many.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::MismachActualFormalParameterList->Altstep_runs_on: number .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: number> module ModuleA { type component MyCT {} altstep MyAltstep( integer par_1, charstring par_2, boolean par_3 ) runs on MyCT { [else] {} } altstep MyAltstep2( integer par_1 := 6, charstring par_2) runs on MyCT { [else] {} } altstep MyAltstep3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false) runs on MyCT { [else] {} } testcase MyTemp() runs on MyCT { MyAltstep(6,"r",true); // good MyAltstep(6,"r"); // too few parameters MyAltstep(56,"r",true,1.3); // too many parameters MyAltstep2("r"); // too few parameters MyAltstep3(6,"r",true,1.3); // too many parameters MyAltstep3(-,"r",true,1.3); // too many parameters MyAltstep3(6,"r",true,-); // too many parameters } } (?im)\berror\b.+?Too.+?few.+?parameters (?im)\berror\b.+?Too.+?many.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::MismachActualFormalParameterList->Testcase: numberr .*---------------------------------------------------------------------* :xmp tab=0. Testcase: number> module ModuleA { type component MyCT {} testcase MyTestcase( integer par_1, charstring par_2, boolean par_3 ) runs on MyCT {} testcase MyTestcase2( integer par_1 := 6, charstring par_2) runs on MyCT {} testcase MyTestcase3( integer par_1:=6, charstring par_2:="r", boolean par_3:=false) runs on MyCT {} control { execute ( MyTestcase(6,"r",true) ); // good execute ( MyTestcase(6,"r") ); // too few parameters execute ( MyTestcase(56,"r",true,1.3) ); // too many parameters execute ( MyTestcase2("r") ); // too few parameters execute ( MyTestcase3(6,"r",true,1.3) ); // too many parameters execute ( MyTestcase3(-,"r",true,1.3) ); // too many parameters execute ( MyTestcase3(6,"r",true,-) ); // too many parameters } } (?im)\berror\b.+?Too.+?few.+?parameters (?im)\berror\b.+?Too.+?many.+?parameters (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::MismachActualFormalParameterList->Signature: number .*---------------------------------------------------------------------* :xmp tab=0. Signature: number> module ModuleA { signature MySig( integer par_1, charstring par_2, boolean par_3 ); type port MyPortType procedure { inout MySig } type component MyComp { port MyPortType MyPort; } function MyFunc() runs on MyComp { MyPort.call(MySig:{ 6,"r",true }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ 6,"r" }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ 6,"r",true,6.8 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } } } (?im)\berror\b.+?Too.+?few.+?elements.+?MySig (?im)\berror\b.+?Too.+?many.+?elements.+?MySig (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. :np. .*---------------------------------------------------------------------* :h2.Parameter list of a modified template .*---------------------------------------------------------------------* This test case group covers the requirement SA-4/4. :p. Explanation: :nl. The followings apply: :nl. - the derived template shall not omit parameters defined at any of the modification steps between the base template and the actual modified template :nl. - a derived template can have additional (appended) parameters if wished :nl. - base template fields containing parameterized templates shall not be modified or explicitly omitted in a modified template (including inline modified templates) :nl. - base template field that depends on a parameter shall not be modified or explicitly omitted in a modified template (?) :p. Test strategy: :p. TODO: :np. .*---------------------------------------------------------------------* :h2.Parameter is not allowed to be passed by value/reference .*---------------------------------------------------------------------* This test case group covers the requirement SA-4/5. :p. Explanation: :nl. Many language elements allow only parameter passing by value or reference. :p. General: :list. :li d='Basic types, basic string types, user-defined structured types, address type and component type:'. By default, all actual parameters of these types are passed by value. :nl.This may otionally be denoted by the keyword "in". :nl.To pass parameters of these types by reference the keywords "out" or "inout" shall be used. :nl.NOTE: the behaviour of the "default" type is similar to the listed below in the implementation. :li d='Timers and ports:'. are always passed by reference. :nl.Timer parameter are identified by the keyword timer. :nl.Port parameter are identified by their port type. :nl.The keyword "inout" may optionally be used to denote passing by reference. :elist. :p. Parameters passed by reference: :nl.Passing parameters by reference has the following limitations: :list. :li d='a)'. only the formal parameter lists to altsteps, functions, signatures and testcases may contain pass-by-reference parameters; :li d='b)'. the actual parameters shall only be variables, ports or timers. :elist. :p. Parameters passed by value: :nl.Actual parameters that are passed by value may be variables as well as constants, templates etc. :p. NOTEs: :nl.The "component type" and the "default" are allowed in the modulepar, the template and the testcase in the implementation far afield from the TTCN-3 specification. :nl.The "out" and the "inout" parameters can be read and set from within e.g. the function. The difference is the "out" parameter may be unbound but the "inout" parameter must be initialized before called. :p. Test strategy: :nl.There are some tests for the template, function, altstep, testcase and signature language elements where we can use "in","out" or "inout" parameters. First we checked the allowed cases (positive tests). Other tests are for each type of values that is allowed to appear in the formal/actual parameter lists of all language elements with "defaul in", "in", "out" and "inout" parameters. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Template: allowed in .*---------------------------------------------------------------------* :xmp tab=0. Template: allowed in> module ModuleA { type component MyCT {} type record MyRecord { float field1, boolean field2 optional } type record address { integer field } type record MyRec { integer field11 optional, integer field12, octetstring field21, octetstring field22, MyRecord field31, MyRecord field32, address field41, address field42, MyCT field51, MyCT field52, default field61, default field62, float field71, float field72 } template MyRec MyTemp ( integer par_11, // basic type in integer par_12, octetstring par_21, // basic string type in octetstring par_22, MyRecord par_31, // user-defined structured type in MyRecord par_32, address par_41, // address in address par_42, template float par_51, // template in template float par_52, MyCT par_61, // component type in MyCT par_62, default par_71, // default in default par_72 ) := { field11 := par_11, field12 := par_12, field21 := par_21, field22 := par_22, field31 := par_31, field32 := par_32, field41 := par_41, field42 := par_42, field51 := par_61, field52 := par_62, field61 := par_71, field62 := par_72, field71 := par_51, field72 := par_52 } function MyFunc( template MyRec mytemp ) {} control { var integer myint; var octetstring myoctet; var MyRecord myrecord; var address myadd; var float mytemp; var MyCT myct_1, myct_2; var default mydef_1, mydef_2; MyFunc(MyTemp( 1,myint, myoctet,'A5'O, myrecord,{6.7,true}, {5},myadd, mytemp,7.8, myct_1,myct_2, mydef_1,mydef_1)); } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Template: allowed non-mandatory in .*---------------------------------------------------------------------* :xmp tab=0. Template: allowed non-mandatory in> module ModuleA { type component MyCT {} type record MyRecord { float field1, boolean field2 optional } type record address { integer field } type record MyRec { integer field11 optional, integer field12, octetstring field21, octetstring field22, MyRecord field31, MyRecord field32, address field41, address field42, MyCT field51, MyCT field52, default field61, default field62, float field71, float field72 } template MyRec MyTemp ( integer par_11 := 1, // basic type in integer par_12 := 1, octetstring par_21 := 'A5'O, // basic string type in octetstring par_22 := 'A5'O, MyRecord par_31 := {6.7,true},// user-defined structured type in MyRecord par_32 := {6.7,true}, address par_41 := {5}, // address in address par_42 := {5}, template float par_51 := 7.8, // template in template float par_52 := 7.8, MyCT par_61, // component type in MyCT par_62, default par_71, // default in default par_72 ) := { field11 := par_11, field12 := par_12, field21 := par_21, field22 := par_22, field31 := par_31, field32 := par_32, field41 := par_41, field42 := par_42, field51 := par_61, field52 := par_62, field61 := par_71, field62 := par_72, field71 := par_51, field72 := par_52 } function MyFunc( template MyRec mytemp ) {} control { var integer myint; var octetstring myoctet; var MyRecord myrecord; var address myadd; var float mytemp; var MyCT myct_1, myct_2; var default mydef_1, mydef_2; MyFunc(MyTemp( 1,myint, myoctet,'A5'O, myrecord,{6.7,true}, {5},myadd, mytemp,7.8, myct_1,myct_2, mydef_1,mydef_1)); } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Template: out, inout .*---------------------------------------------------------------------* :xmp tab=0. Template: out, inout> module ModuleA { type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer field } type record MyRec { integer field1 optional, octetstring field2, MySet field3, address field4, MyCT field5, default field6, float field7 } template MyRec MyTemp ( out integer par_13_1, // basic type inout integer par_14_1, out octetstring par_13_2, // basic string type inout octetstring par_14_2, out MySet par_23, // user-defined structured type inout MySet par_24, out address par_33, // address inout address par_34, out template float par_43, // template inout template float par_44, out MyCT par_53, // component type inout MyCT par_54, out default par_73, // default inout default par_74 ) := { field1 := par_13_1, field2 := par_14_2, field3 := par_23, field4 := par_34, field5 := par_53, field6 := par_74, field7 := par_44 } } (?im)\berror\b.+?template.+?cannot.+?have.+?out.+?parameter (?im)\berror\b.+?template.+?cannot.+?have.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Template: non-mandatory out, inout .*---------------------------------------------------------------------* :xmp tab=0. Template: non-mandatory out, inout> module ModuleA { type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer field } type record MyRec { integer field1 optional, octetstring field2, MySet field3, address field4, float field5 } template MyRec MyTemp ( out integer par_13_1 := 5, // basic type inout integer par_14_1 := 5, out octetstring par_13_2 := 'A5'O, // basic string type inout octetstring par_14_2 := 'A5'O, out MySet par_23 := {field1:=1.0,field2:=true}, // user-defined structured type inout MySet par_24 := {field1:=1.0,field2:=true}, out address par_33 := {5}, // address inout address par_34 := {5}, out template float par_43 := 7.8, // template inout template float par_44 := 7.8) := { field1 := par_13_1, field2 := par_14_2, field3 := par_23, field4 := par_34, field5 := par_44 } } (?im)\berror\b.+?template.+?cannot.+?have.+?out.+?parameter (?im)\berror\b.+?template.+?cannot.+?have.+?inout.+?parameter (?im)\berror\b.+?reference.+?variable.+?value.+?parameter.+?expected (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: allowed in/out/inout .*---------------------------------------------------------------------* :xmp tab=0. Function: allowed in/out/inout> module ModuleA { type port MyPort message { inout charstring; } type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer field } function MyFunc ( integer par_11_1, // basic type in integer par_12_1, out integer par_13_1, inout integer par_14_1, octetstring par_11_2, // basic string type in octetstring par_12_2, out octetstring par_13_2, inout octetstring par_14_2, MySet par_21, // user-defined structured type in MySet par_22, out MySet par_23, inout MySet par_24, address par_31, // address in address par_32, out address par_33, inout address par_34, template MySet par_41, // template in template MySet par_42, out template MySet par_43, inout template MySet par_44, MyCT par_51, // component type in MyCT par_52, out MyCT par_53, inout MyCT par_54, MyPort par_61, // port type inout MyPort par_64, default par_71, // default in default par_72, out default par_73, inout default par_74, timer par_81, // timer inout timer par_84 ) {} } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: allowed in/out/inout .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: allowed in/out/inout> module ModuleA { type port MyPort message { inout charstring; } type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer field } function MyCompFunc ( integer par_11_1, // basic type in integer par_12_1, out integer par_13_1, inout integer par_14_1, octetstring par_11_2, // basic string type in octetstring par_12_2, out octetstring par_13_2, inout octetstring par_14_2, MySet par_21, // user-defined structured type in MySet par_22, out MySet par_23, inout MySet par_24, address par_31, // address in address par_32, out address par_33, inout address par_34, template MySet par_41, // template in template MySet par_42, out template MySet par_43, inout template MySet par_44, MyCT par_51, // component type in MyCT par_52, out MyCT par_53, inout MyCT par_54, MyPort par_61, // port type inout MyPort par_64, default par_71, // default in default par_72, out default par_73, inout default par_74, timer par_81, // timer inout timer par_84 ) runs on MyCT {} } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: allowed non-mandatory in/out/inout .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: allowed non-mandatory in/out/inout> module ModuleA { type port MyPort message { inout charstring; } type set MySet { float field1, boolean field2 optional } type record address { integer field } type component MyCT { const integer comp_const_i := 0; var integer comp_var_i := 0; const octetstring comp_const_o := '00'O; var octetstring comp_var_o := '00'O; const MySet comp_const_set := {field1 := 1.0, field2 := true}; var MySet comp_var_set := {field1 := 1.0, field2 := true}; const address comp_const_address := {5}; var address comp_var_address := {5}; port MyPort comp_port; timer comp_timer := 1.0; } function MyCompFunc ( integer par_11_1 := comp_const_i, // basic type in integer par_12_1 := comp_const_i, out integer par_13_1 := comp_var_i, inout integer par_14_1 := comp_var_i, octetstring par_11_2 := comp_const_o, // basic string type in octetstring par_12_2 := comp_const_o, out octetstring par_13_2 := comp_var_o, inout octetstring par_14_2 := comp_var_o, MySet par_21 := comp_const_set, // user-defined structured type in MySet par_22 := comp_const_set, out MySet par_23 := comp_var_set, inout MySet par_24 := comp_var_set, address par_31 := comp_const_address, // address in address par_32 := comp_const_address, out address par_33 := comp_var_address, inout address par_34 := comp_var_address, MyPort par_61 := comp_port, // port type inout MyPort par_64 := comp_port, timer par_81 := comp_timer, // timer inout timer par_84 := comp_timer ) runs on MyCT {} } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: allowed in/out/inout .*---------------------------------------------------------------------* :xmp tab=0. External Function: allowed in/out/inout> module ModuleA { type port MyPort message { inout charstring; } type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer field } external function MyExtFunc ( integer par_11_1, // basic type in integer par_12_1, out integer par_13_1, inout integer par_14_1, octetstring par_11_2, // basic string type in octetstring par_12_2, out octetstring par_13_2, inout octetstring par_14_2, MySet par_21, // user-defined structured type in MySet par_22, out MySet par_23, inout MySet par_24, address par_31, // address in address par_32, out address par_33, inout address par_34, template MySet par_41, // template in template MySet par_42, out template MySet par_43, inout template MySet par_44, MyCT par_51, // component type in MyCT par_52, out MyCT par_53, inout MyCT par_54, MyPort par_61, // port type inout MyPort par_64, default par_71, // default in default par_72, out default par_73, inout default par_74, timer par_81, // timer inout timer par_84 ); } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: port type with in/out .*---------------------------------------------------------------------* :xmp tab=0. Function: port type with in/out> module ModuleA { type port MyPort message { inout charstring; } type component MyCT {} function MyFunc ( in MyPort par_1, out MyPort par_2 ) {} function MyCompFunc ( in MyPort par_1, out MyPort par_2 ) {} external function MyExtFunc ( in MyPort par_1, out MyPort par_2 ); } (?im)\berror\b.+?Port.+?cannot.+?used.+?value (?im)\berror\b.+?Port.+?cannot.+?used.+?out.+?value (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: timer with in/out .*---------------------------------------------------------------------* :xmp tab=0. Function: timer with in/out> module ModuleA { type component MyCT {} function MyFunc ( in timer par_1, out timer par_2 ) {} function MyCompFunc ( in timer par_1, out timer par_2 ) {} external function MyExtFunc ( in timer par_1, out timer par_2 ); } (?im)\berror\b.+?syntax.+?error (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: basic type .*---------------------------------------------------------------------* :xmp tab=0. Function: basic type> module ModuleA { function MyFunc ( integer par_1, // basic type in integer par_2, out integer par_3, inout integer par_4 ) { var integer temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } control { var integer var_1 := 1; var integer var_2 := 2; var integer var_3 := 3; var integer var_4 := 4; var integer var_11, var_22, var_33, var_44; MyFunc( var_1, var_2, var_3, var_4); // good MyFunc( var_11, var_22, var_33, var_44); // good MyFunc( 1, 2, var_3, var_4); // good MyFunc( 1, 2, 3, 4); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: basic type as non-mandatory parameter .*---------------------------------------------------------------------* :xmp tab=0. Function: basic type as non-mandatory parameter> module ModuleA { function MyFunc ( integer par_1 := 1, // basic type in integer par_2 := 1, out integer par_3 := 1, inout integer par_4 := 1 ) { } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: basic type .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: basic type> module ModuleA { type component MyCT {} function MyCompFunc ( integer par_1, // basic type in integer par_2, out integer par_3, inout integer par_4 ) runs on MyCT { var integer temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } function MyTempFunc () runs on MyCT { var integer var_1 := 1; var integer var_2 := 2; var integer var_3 := 3; var integer var_4 := 4; var integer var_11, var_22, var_33, var_44; MyCompFunc( var_1, var_2, var_3, var_4); // good MyCompFunc( var_11, var_22, var_33, var_44); // good MyCompFunc( 1, 2, var_3, var_4); // good MyCompFunc( 1, 2, 3, 4); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: basic type .*---------------------------------------------------------------------* :xmp tab=0. External Function: basic type> module ModuleA { external function MyExtFunc ( integer par_1, // basic type in integer par_2, out integer par_3, inout integer par_4 ); control { var integer var_1 := 1; var integer var_2 := 2; var integer var_3 := 3; var integer var_4 := 4; var integer var_11, var_22, var_33, var_44; MyExtFunc( var_1, var_2, var_3, var_4); // good MyExtFunc( var_11, var_22, var_33, var_44); // good MyExtFunc( 1, 2, var_3, var_4); // good MyExtFunc( 1, 2, 3, 4); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: basic type as non-mandatory parameter .*---------------------------------------------------------------------* :xmp tab=0. External Function: basic type as non-mandatory parameter> module ModuleA { external function MyExtFunc ( integer par_1 := 1, // basic type in integer par_2 := 1, out integer par_3 := 1, inout integer par_4 := 1 ); } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: basic string type .*---------------------------------------------------------------------* :xmp tab=0. Function: basic string type> module ModuleA { function MyFunc ( charstring par_1, // basic string type in charstring par_2, out charstring par_3, inout charstring par_4 ) { var charstring temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } control { var charstring var_1 := "q"; var charstring var_2 := "w"; var charstring var_3 := "e"; var charstring var_4 := "r"; var charstring var_11, var_22, var_33, var_44; MyFunc( var_1, var_2, var_3, var_4); // good MyFunc( var_11, var_22, var_33, var_44); // good MyFunc( "w", "e", var_3, var_4); // good MyFunc( "q", "b", "5", "w"); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: basic string type .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: basic string type> module ModuleA { type component MyCT {} function MyCompFunc ( charstring par_1, // basic string type in charstring par_2, out charstring par_3, inout charstring par_4 ) runs on MyCT { var charstring temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } function MyTempFunc () runs on MyCT { var charstring var_1 := "q"; var charstring var_2 := "w"; var charstring var_3 := "e"; var charstring var_4 := "r"; var charstring var_11, var_22, var_33, var_44; MyCompFunc( var_1, var_2, var_3, var_4); // good MyCompFunc( var_11, var_22, var_33, var_44); // good MyCompFunc( "w", "e", var_3, var_4); // good MyCompFunc( "q", "b", "5", "w"); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: basic string type .*---------------------------------------------------------------------* :xmp tab=0. External Function: basic string type> module ModuleA { external function MyExtFunc ( charstring par_1, // basic string type in charstring par_2, out charstring par_3, inout charstring par_4 ); control { var charstring var_1 := "q"; var charstring var_2 := "w"; var charstring var_3 := "e"; var charstring var_4 := "r"; var charstring var_11, var_22, var_33, var_44; MyExtFunc( var_1, var_2, var_3, var_4); // good MyExtFunc( var_11, var_22, var_33, var_44); // good MyExtFunc( "w", "e", var_3, var_4); // good MyExtFunc( "q", "b", "5", "w"); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: user-defined type .*---------------------------------------------------------------------* :xmp tab=0. Function: user-defined type> module ModuleA { type set MySet { float field1, boolean field2 optional } function MyFunc ( MySet par_1, // user-defined type in MySet par_2, out MySet par_3, inout MySet par_4 ) { var MySet temp := { field1:=par_1.field1 } par_1.field1 := par_2.field1; par_2.field1 := par_3.field1; par_3.field1 := par_4.field1; par_4.field1 := temp.field1; } control { var MySet var_1 := { field1:=1.3 }; var MySet var_2 := { field1:=2.5 }; var MySet var_3 := { field1:=3.1 }; var MySet var_4 := { field1:=4.9 }; var MySet var_11, var_22, var_33, var_44; MyFunc(var_1,var_2,var_3,var_4); // good MyFunc(var_11,var_22,var_33,var_44); // good MyFunc( {field1:=1.2, field2:=true}, // good {field1:=2.5, field2:=true}, var_3, var_4); MyFunc( {field1:=1.2, field2:=true}, // error {field1:=2.5, field2:=true}, {field1:=3.6, field2:=true}, {field1:=4.1, field2:=true}); } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: user-defined type .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: user-defined type> module ModuleA { type component MyCT {} type set MySet { float field1, boolean field2 optional } function MyCompFunc ( MySet par_1, // user-defined type in MySet par_2, out MySet par_3, inout MySet par_4 ) runs on MyCT { var MySet temp := { field1:=par_1.field1 } par_1.field1 := par_2.field1; par_2.field1 := par_3.field1; par_3.field1 := par_4.field1; par_4.field1 := temp.field1; } function MyTempFunc () runs on MyCT { var MySet var_1 := { field1:=1.3 }; var MySet var_2 := { field1:=2.5 }; var MySet var_3 := { field1:=3.1 }; var MySet var_4 := { field1:=4.9 }; var MySet var_11, var_22, var_33, var_44; MyCompFunc(var_1,var_2,var_3,var_4); // good MyCompFunc(var_11,var_22,var_33,var_44); // good MyCompFunc( {field1:=1.2, field2:=true}, // good {field1:=2.5, field2:=true}, var_3, var_4); MyCompFunc( {field1:=1.2, field2:=true}, // error {field1:=2.5, field2:=true}, {field1:=3.6, field2:=true}, {field1:=4.1, field2:=true}); } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: user-defined type .*---------------------------------------------------------------------* :xmp tab=0. External Function: user-defined type> module ModuleA { type set MySet { float field1, boolean field2 optional } external function MyExtFunc ( MySet par_1, // user-defined type in MySet par_2, out MySet par_3, inout MySet par_4 ); control { var MySet var_1 := { field1:=1.3 }; var MySet var_2 := { field1:=2.5 }; var MySet var_3 := { field1:=3.1 }; var MySet var_4 := { field1:=4.9 }; var MySet var_11, var_22, var_33, var_44; MyExtFunc(var_1,var_2,var_3,var_4); // good MyExtFunc(var_11,var_22,var_33,var_44); // good MyExtFunc( {field1:=1.2, field2:=true}, // good {field1:=2.5, field2:=true}, var_3, var_4); MyExtFunc( {field1:=1.2, field2:=true}, // error {field1:=2.5, field2:=true}, {field1:=3.6, field2:=true}, {field1:=4.1, field2:=true}); } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: address type .*---------------------------------------------------------------------* :xmp tab=0. Function: address type> module ModuleA { type record address { integer field } function MyFunc ( address par_1, // address type in address par_2, out address par_3, inout address par_4 ) { var address temp := { field:=par_1.field }; par_1.field := par_2.field; par_2.field := par_3.field; par_3.field := par_4.field; par_4.field := temp.field; } control { var address var_1 := { field:=1 }; var address var_2 := { field:=2 }; var address var_3 := { field:=3 }; var address var_4 := { field:=4 }; var address var_11, var_22, var_33, var_44; MyFunc( {1}, {2}, var_3, var_4 ); // good MyFunc( var_1, var_2, var_3, var_4 ); // good MyFunc( var_11, var_22, var_33, var_44 ); // good MyFunc( {1}, {2}, {3}, {4} ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: address type .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: address type> module ModuleA { type component MyCT {} type record address { integer field } function MyCompFunc ( address par_1, // address type in address par_2, out address par_3, inout address par_4 ) runs on MyCT { var address temp := { field:=par_1.field }; par_1.field := par_2.field; par_2.field := par_3.field; par_3.field := par_4.field; par_4.field := temp.field; } function MyTempFunc () runs on MyCT { var address var_1 := { field:=1 }; var address var_2 := { field:=2 }; var address var_3 := { field:=3 }; var address var_4 := { field:=4 }; var address var_11, var_22, var_33, var_44; MyCompFunc( {1}, {2}, var_3, var_4 ); // good MyCompFunc( var_1, var_2, var_3, var_4 ); // good MyCompFunc( var_11, var_22, var_33, var_44 ); // good MyCompFunc( {1}, {2}, {3}, {4} ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: address type .*---------------------------------------------------------------------* :xmp tab=0. External Function: address type> module ModuleA { type record address { integer field } external function MyExtFunc ( address par_1, // address type in address par_2, out address par_3, inout address par_4 ); control { var address var_1 := { field:=1 }; var address var_2 := { field:=2 }; var address var_3 := { field:=3 }; var address var_4 := { field:=4 }; var address var_11, var_22, var_33, var_44; MyExtFunc( {1}, {2}, var_3, var_4 ); // good MyExtFunc( var_1, var_2, var_3, var_4 ); // good MyExtFunc( var_11, var_22, var_33, var_44 ); // good MyExtFunc( {1}, {2}, {3}, {4} ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: template .*---------------------------------------------------------------------* :xmp tab=0. Function: template> module ModuleA { function MyFunc ( template float par_1, // template in template float par_2, out template float par_3, inout template float par_4 ) { var float temp; temp := valueof ( par_1 ); temp := valueof ( par_2 ); temp := valueof ( par_3 ); temp := valueof ( par_4 ); par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } control { var float var_1 := 1.3; var float var_2 := 2.5; var float var_3 := 3.1; var float var_4 := 4.9; var template float var_11, var_22, var_33, var_44; MyFunc( 1.1, 2.8, var_33, var_44); // good MyFunc( var_11, var_22, var_33, var_44); // good MyFunc( var_1, var_2, var_3, var_4); // error MyFunc( 1.1, 2.8, 3.53, 4.94); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: template .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: template> module ModuleA { type component MyCT {} function MyCompFunc ( template float par_1, // template in template float par_2, out template float par_3, inout template float par_4 ) runs on MyCT { var float temp; temp := valueof ( par_1 ); temp := valueof ( par_2 ); temp := valueof ( par_3 ); temp := valueof ( par_4 ); par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } function MyTempFunc () runs on MyCT { var float var_1 := 1.3; var float var_2 := 2.5; var float var_3 := 3.1; var float var_4 := 4.9; var template float var_11, var_22, var_33, var_44; MyCompFunc( 1.1, 2.8, var_33, var_44); // good MyCompFunc( var_11, var_22, var_33, var_44); // good MyCompFunc( var_1, var_2, var_3, var_4); // error MyCompFunc( 1.1, 2.8, 3.53, 4.94); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: template .*---------------------------------------------------------------------* :xmp tab=0. External Function: template> module ModuleA { external function MyExtFunc ( template float par_1, // template in template float par_2, out template float par_3, inout template float par_4 ); control { var float var_1 := 1.3; var float var_2 := 2.5; var float var_3 := 3.1; var float var_4 := 4.9; var template float var_11, var_22, var_33, var_44; MyExtFunc( 1.1, 2.8, var_33, var_44); // good MyExtFunc( var_11, var_22, var_33, var_44); // good MyExtFunc( var_1, var_2, var_3, var_4); // error MyExtFunc( 1.1, 2.8, 3.53, 4.94); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: component type .*---------------------------------------------------------------------* :xmp tab=0. Function: component type> module ModuleA { type component MyCT {} function MyFunc ( MyCT par_1, // component type in MyCT par_2, out MyCT par_3, inout MyCT par_4 ) { var MyCT temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } function MyCompFunc () runs on MyCT { var MyCT temp, var_1, var_2, var_3, var_4; temp := MyCT.create; MyFunc( var_1, var_2, var_3, var_4 ); // good MyFunc( temp, temp, temp, temp); // good MyFunc( MyCT.create, MyCT.create, temp, temp ); // good MyFunc( MyCT.create, MyCT.create, MyCT.create, MyCT.create ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: component type .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: component type> module ModuleA { type component MyCT {} function MyCompFunc ( MyCT par_1, // component type in MyCT par_2, out MyCT par_3, inout MyCT par_4 ) runs on MyCT { var MyCT temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } function MyTempFunc () runs on MyCT { var MyCT temp, var_1, var_2, var_3, var_4; temp := MyCT.create; MyCompFunc( var_1, var_2, var_3, var_4 ); // good MyCompFunc( temp, temp, temp, temp); // good MyCompFunc( MyCT.create, MyCT.create, temp, temp ); // good MyCompFunc( MyCT.create, MyCT.create, MyCT.create, MyCT.create ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: component type .*---------------------------------------------------------------------* :xmp tab=0. External Function: component type> module ModuleA { type component MyCT {} external function MyExtFunc ( MyCT par_1, // component type in MyCT par_2, out MyCT par_3, inout MyCT par_4 ); function MyTempFunc () runs on MyCT { var MyCT temp, var_1, var_2, var_3, var_4; temp := MyCT.create; MyExtFunc( var_1, var_2, var_3, var_4 ); // good MyExtFunc( temp, temp, temp, temp); // good MyExtFunc( MyCT.create, MyCT.create, temp, temp ); // good MyExtFunc( MyCT.create, MyCT.create, MyCT.create, MyCT.create ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: port type .*---------------------------------------------------------------------* :xmp tab=0. Function: port type> module ModuleA { type port MyPort message { inout charstring; } // port type type component MyCT { port MyPort port_1; port MyPort port_2; } function MyFunc ( MyPort par_1, inout MyPort par_2 ) { par_1 := par_2; par_2 := par_1; } function MyCompFunc ( MyPort par_1, inout MyPort par_2 ) runs on MyCT { port_1 := par_1; par_1 := par_2; par_2 := port_1; } external function MyExtFunc ( MyPort par_1, inout MyPort par_2 ); function MyTempFunc ( MyPort par_1, inout MyPort par_2 ) runs on MyCT { MyFunc( port_1, port_2 ); MyCompFunc( port_1, port_2 ); MyExtFunc( port_1, port_2 ); } } (?im)\berror\b.+?Reference.+?expected.+?instead of.+?port_1 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2 (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: default .*---------------------------------------------------------------------* :xmp tab=0. Function: default> module ModuleA { function MyFunc ( default par_1, // default in default par_2, out default par_3, inout default par_4 ) { var default temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } control { var default var_1, var_2, var_3, var_4; var default temp := null; MyFunc( var_1, var_2, var_3, var_4 ); // good MyFunc( temp, temp, temp, temp); // good MyFunc( null, null, temp, temp); // good MyFunc( null, null, null, null); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: default .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: default> module ModuleA { type component MyCT {} function MyCompFunc ( default par_1, // default type in default par_2, out default par_3, inout default par_4 ) runs on MyCT { var default temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } function MyTempFunc () runs on MyCT { var default var_1, var_2, var_3, var_4; var default temp := null; MyCompFunc( var_1, var_2, var_3, var_4 ); // good MyCompFunc( temp, temp, temp, temp); // good MyCompFunc( null, null, temp, temp); // good MyCompFunc( null, null, null, null); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: default .*---------------------------------------------------------------------* :xmp tab=0. External Function: default> module ModuleA { external function MyExtFunc ( default par_1, // default type in default par_2, out default par_3, inout default par_4 ); control { var default var_1, var_2, var_3, var_4; var default temp := null; MyExtFunc( var_1, var_2, var_3, var_4 ); // good MyExtFunc( temp, temp, temp, temp); // good MyExtFunc( null, null, temp, temp); // good MyExtFunc( null, null, null, null); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: timer .*---------------------------------------------------------------------* :xmp tab=0. Function: timer> module ModuleA { type component MyCT {} function MyFunc ( timer par_1, inout timer par_2 ) { timer temp := 2.3; temp := par_1; // error par_1 := par_2; // error par_2 := temp; // error } control { timer T1 := 2.9; timer T2 := 5.7; timer T3, T4; MyFunc( T1, T2 ); // good MyFunc( T3, T4 ); // good MyFunc( 3.8, 4.5 ); // error } } (?im)\berror\b.+?Reference.+?expected.+?instead of.+?temp (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2 (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function: timer as non-mandatory parameter .*---------------------------------------------------------------------* :xmp tab=0. Function: timer as non-mandatory parameter> module ModuleA { function MyFunc ( timer par_1 := 1.0, // basic type inout timer par_4 := 1.0 ) {}; } (?im)\berror\b.+?Reference.+?timer.+?expected.+?for.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Function_runs_on: timer .*---------------------------------------------------------------------* :xmp tab=0. Function_runs_on: timer> module ModuleA { type component MyCT {} function MyCompFunc ( timer par_1, inout timer par_2 ) runs on MyCT { timer temp := 2.3; temp := par_1; // error par_1 := par_2; // error par_2 := temp; // error } function MyTempFunc () runs on MyCT { timer T1 := 2.9; timer T2 := 5.7; timer T3, T4; MyCompFunc( T1, T2 ); // good MyCompFunc( T3, T4 ); // good MyCompFunc( 3.8, 4.5 ); // error } } (?im)\berror\b.+?Reference.+?expected.+?instead of.+?temp (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2 (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->External Function: timer .*---------------------------------------------------------------------* :xmp tab=0. External Function: timer> module ModuleA { type component MyCT {} external function MyExtFunc ( timer par_1, inout timer par_2 ); control { timer T1 := 2.9; timer T2 := 5.7; timer T3, T4; MyExtFunc( T1, T2 ); // good MyExtFunc( T3, T4 ); // good MyExtFunc( 3.8, 4.5 ); // error } } (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: allowed in/out/inout .*---------------------------------------------------------------------* :xmp tab=0. Altstep: allowed in/out/inout> module ModuleA { type port MyPort message { inout charstring; } type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer field } altstep MyAltstep ( integer par_11_1, // basic type in integer par_12_1, out integer par_13_1, inout integer par_14_1, octetstring par_11_2, // basic string type in octetstring par_12_2, out octetstring par_13_2, inout octetstring par_14_2, MySet par_21, // user-defined structured type in MySet par_22, out MySet par_23, inout MySet par_24, address par_31, // address in address par_32, out address par_33, inout address par_34, template MySet par_41, // template in template MySet par_42, out template MySet par_43, inout template MySet par_44, MyCT par_51, // component type in MyCT par_52, out MyCT par_53, inout MyCT par_54, MyPort par_61, // port type inout MyPort par_64, default par_71, // default in default par_72, out default par_73, inout default par_74, timer par_81, // timer inout timer par_84 ) { [else] {} } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: allowed in/out/inout .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: allowed in/out/inout> module ModuleA { type port MyPort message { inout charstring; } type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer field } altstep MyCompAltstep ( integer par_11_1, // basic type in integer par_12_1, out integer par_13_1, inout integer par_14_1, octetstring par_11_2, // basic string type in octetstring par_12_2, out octetstring par_13_2, inout octetstring par_14_2, MySet par_21, // user-defined structured type in MySet par_22, out MySet par_23, inout MySet par_24, address par_31, // address in address par_32, out address par_33, inout address par_34, template MySet par_41, // template in template MySet par_42, out template MySet par_43, inout template MySet par_44, MyCT par_51, // component type in MyCT par_52, out MyCT par_53, inout MyCT par_54, MyPort par_61, // port type inout MyPort par_64, default par_71, // default in default par_72, out default par_73, inout default par_74, timer par_81, // timer inout timer par_84 ) runs on MyCT { [else] {} } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: allowed non-mandatory in/out/inout .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: allowed non-mandatory in/out/inout> module ModuleA { type port MyPort message { inout charstring; } type set MySet { float field1, boolean field2 optional } type record address { integer field } type component MyCT { const integer comp_const_i := 0; var integer comp_var_i := 0; const octetstring comp_const_o := '00'O; var octetstring comp_var_o := '00'O; const MySet comp_const_set := {field1 := 1.0, field2 := true}; var MySet comp_var_set := {field1 := 1.0, field2 := true}; const address comp_const_address := {5}; var address comp_var_address := {5}; port MyPort comp_port; timer comp_timer := 1.0; } altstep MyCompAltstep ( integer par_11_1 := comp_const_i, // basic type in integer par_12_1 := comp_const_i, out integer par_13_1 := comp_var_i, inout integer par_14_1 := comp_var_i, octetstring par_11_2 := comp_const_o, // basic string type in octetstring par_12_2 := comp_const_o, out octetstring par_13_2 := comp_var_o, inout octetstring par_14_2 := comp_var_o, MySet par_21 := comp_const_set, // user-defined structured type in MySet par_22 := comp_const_set, out MySet par_23 := comp_var_set, inout MySet par_24 := comp_var_set, address par_31 := comp_const_address, // address in address par_32 := comp_const_address, out address par_33 := comp_var_address, inout address par_34 := comp_var_address, MyPort par_61 := comp_port, // port type inout MyPort par_64 := comp_port, timer par_81 := comp_timer, // timer inout timer par_84 := comp_timer ) runs on MyCT { [else] {} } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: port type with in/out .*---------------------------------------------------------------------* :xmp tab=0. Altstep: port type with in/out> module ModuleA { type port MyPort message { inout charstring; } type component MyCT {} altstep MyFunc ( in MyPort par_1, out MyPort par_2 ) { [else] {} } altstep MyCompFunc ( in MyPort par_1, out MyPort par_2 ) { [else] {} } } (?im)\berror\b.+?Port.+?cannot.+?used.+?value (?im)\berror\b.+?Port.+?cannot.+?used.+?out.+?value (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: timer with in/out .*---------------------------------------------------------------------* :xmp tab=0. Altstep: timer with in/out> module ModuleA { type component MyCT {} altstep MyFunc ( in timer par_1, out timer par_2 ) { [else] {} } altstep MyCompFunc ( in timer par_1, out timer par_2 ) { [else] {} } } (?im)\berror\b.+?syntax.+?error (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: basic type .*---------------------------------------------------------------------* :xmp tab=0. Altstep: basic type> module ModuleA { altstep MyAltstep ( integer par_1, // basic type in integer par_2, out integer par_3, inout integer par_4 ) { var integer temp := par_1; [else] { par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } } control { var integer var_1 := 1; var integer var_2 := 2; var integer var_3 := 3; var integer var_4 := 4; var integer var_11, var_22, var_33, var_44; MyAltstep( var_1, var_2, var_3, var_4); // good MyAltstep( var_11, var_22, var_33, var_44); // good MyAltstep( 1, 2, var_3, var_4); // good MyAltstep( 1, 2, 3, 4); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: basic type as non-mandatory parameter .*---------------------------------------------------------------------* :xmp tab=0. Altstep: basic type as non-mandatory parameter> module ModuleA { altstep MyAltstep ( integer par_1 := 1, // basic type in integer par_2 := 1, out integer par_3 := 1, inout integer par_4 := 1 ) { [else] {} } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: basic type .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: basic type> module ModuleA { type component MyCT {} altstep MyCompAltstep ( integer par_1, // basic type in integer par_2, out integer par_3, inout integer par_4 ) runs on MyCT { var integer temp := par_1; [else] { par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } } function MyCompFunc () runs on MyCT { var integer var_1 := 1; var integer var_2 := 2; var integer var_3 := 3; var integer var_4 := 4; var integer var_11, var_22, var_33, var_44; MyCompAltstep( var_1, var_2, var_3, var_4); // good MyCompAltstep( var_11, var_22, var_33, var_44); // good MyCompAltstep( 1, 2, var_3, var_4); // good MyCompAltstep( 1, 2, 3, 4); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: basic string type .*---------------------------------------------------------------------* :xmp tab=0. Altstep: basic string type> module ModuleA { altstep MyAltstep ( charstring par_1, // basic string type in charstring par_2, out charstring par_3, inout charstring par_4 ) { var charstring temp := par_1; [else] { par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } } control { var charstring var_1 := "q"; var charstring var_2 := "w"; var charstring var_3 := "e"; var charstring var_4 := "r"; var charstring var_11, var_22, var_33, var_44; MyAltstep( var_1, var_2, var_3, var_4); // good MyAltstep( var_11, var_22, var_33, var_44); // good MyAltstep( "w", "e", var_3, var_4); // good MyAltstep( "q", "b", "5", "w"); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: basic string type .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: basic string type> module ModuleA { type component MyCT {} altstep MyCompAltstep ( charstring par_1, // basic string type in charstring par_2, out charstring par_3, inout charstring par_4 ) runs on MyCT { var charstring temp := par_1; [else] { par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } } function MyCompFunc () runs on MyCT { var charstring var_1 := "q"; var charstring var_2 := "w"; var charstring var_3 := "e"; var charstring var_4 := "r"; var charstring var_11, var_22, var_33, var_44; MyCompAltstep( var_1, var_2, var_3, var_4); // good MyCompAltstep( var_11, var_22, var_33, var_44); // good MyCompAltstep( "w", "e", var_3, var_4); // good MyCompAltstep( "q", "b", "5", "w"); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: user-defined type .*---------------------------------------------------------------------* :xmp tab=0. Altstep: user-defined type> module ModuleA { type set MySet { float field1, boolean field2 optional } altstep MyAltstep ( MySet par_1, // user-defined type in MySet par_2, out MySet par_3, inout MySet par_4 ) { var MySet temp := { field1:=par_1.field1 } [else] { par_1.field1 := par_2.field1; par_2.field1 := par_3.field1; par_3.field1 := par_4.field1; par_4.field1 := temp.field1; } } control { var MySet var_1 := { field1:=1.3 }; var MySet var_2 := { field1:=2.5 }; var MySet var_3 := { field1:=3.1 }; var MySet var_4 := { field1:=4.9 }; var MySet var_11, var_22, var_33, var_44; MyAltstep(var_1,var_2,var_3,var_4); // good MyAltstep(var_11,var_22,var_33,var_44); // good MyAltstep( {field1:=1.2, field2:=true}, // good {field1:=2.5, field2:=true}, var_3, var_4); MyAltstep( {field1:=1.2, field2:=true}, // error {field1:=2.5, field2:=true}, {field1:=3.6, field2:=true}, {field1:=4.1, field2:=true}); } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: user-defined type .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: user-defined type> module ModuleA { type component MyCT {} type set MySet { float field1, boolean field2 optional } altstep MyCompAltstep ( MySet par_1, // user-defined type in MySet par_2, out MySet par_3, inout MySet par_4 ) runs on MyCT { var MySet temp := { field1:=par_1.field1 } [else] { par_1.field1 := par_2.field1; par_2.field1 := par_3.field1; par_3.field1 := par_4.field1; par_4.field1 := temp.field1; } } function MyCompFunc () runs on MyCT { var MySet var_1 := { field1:=1.3 }; var MySet var_2 := { field1:=2.5 }; var MySet var_3 := { field1:=3.1 }; var MySet var_4 := { field1:=4.9 }; var MySet var_11, var_22, var_33, var_44; MyCompAltstep(var_1,var_2,var_3,var_4); // good MyCompAltstep(var_11,var_22,var_33,var_44); // good MyCompAltstep( {field1:=1.2, field2:=true}, // good {field1:=2.5, field2:=true}, var_3, var_4); MyCompAltstep( {field1:=1.2, field2:=true}, // error {field1:=2.5, field2:=true}, {field1:=3.6, field2:=true}, {field1:=4.1, field2:=true}); } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: address type .*---------------------------------------------------------------------* :xmp tab=0. Altstep: address type> module ModuleA { type record address { integer field } altstep MyAltstep ( address par_1, // address type in address par_2, out address par_3, inout address par_4 ) { var address temp := { field:=par_1.field }; [else] { par_1.field := par_2.field; par_2.field := par_3.field; par_3.field := par_4.field; par_4.field := temp.field; } } control { var address var_1 := { field:=1 }; var address var_2 := { field:=2 }; var address var_3 := { field:=3 }; var address var_4 := { field:=4 }; var address var_11, var_22, var_33, var_44; MyAltstep( {1}, {2}, var_3, var_4 ); // good MyAltstep( var_1, var_2, var_3, var_4 ); // good MyAltstep( var_11, var_22, var_33, var_44 ); // good MyAltstep( {1}, {2}, {3}, {4} ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: address type .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: address type> module ModuleA { type component MyCT {} type record address { integer field } altstep MyCompAltstep ( address par_1, // address type in address par_2, out address par_3, inout address par_4 ) runs on MyCT { var address temp := { field:=par_1.field }; [else] { par_1.field := par_2.field; par_2.field := par_3.field; par_3.field := par_4.field; par_4.field := temp.field; } } function MyCompFunc () runs on MyCT { var address var_1 := { field:=1 }; var address var_2 := { field:=2 }; var address var_3 := { field:=3 }; var address var_4 := { field:=4 }; var address var_11, var_22, var_33, var_44; MyCompAltstep( {1}, {2}, var_3, var_4 ); // good MyCompAltstep( var_1, var_2, var_3, var_4 ); // good MyCompAltstep( var_11, var_22, var_33, var_44 ); // good MyCompAltstep( {1}, {2}, {3}, {4} ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: template .*---------------------------------------------------------------------* :xmp tab=0. Altstep: template> module ModuleA { altstep MyAltstep ( template float par_1, // template in template float par_2, out template float par_3, inout template float par_4 ) { var float temp; [else] { temp := valueof ( par_1 ); temp := valueof ( par_2 ); temp := valueof ( par_3 ); temp := valueof ( par_4 ); par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } } control { var float var_1 := 1.3; var float var_2 := 2.5; var float var_3 := 3.1; var float var_4 := 4.9; var template float var_11, var_22, var_33, var_44; MyAltstep( 1.1, 2.8, var_33, var_44); // good MyAltstep( var_11, var_22, var_33, var_44); // good MyAltstep( var_1, var_2, var_3, var_4); // error MyAltstep( 1.1, 2.8, 3.53, 4.94); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: template .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: template> module ModuleA { type component MyCT {} altstep MyCompAltstep ( template float par_1, // template in template float par_2, out template float par_3, inout template float par_4 ) runs on MyCT { var float temp; [else] { temp := valueof ( par_1 ); temp := valueof ( par_2 ); temp := valueof ( par_3 ); temp := valueof ( par_4 ); par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } } function MyCompFunc () runs on MyCT { var float var_1 := 1.3; var float var_2 := 2.5; var float var_3 := 3.1; var float var_4 := 4.9; var template float var_11, var_22, var_33, var_44; MyCompAltstep( 1.1, 2.8, var_33, var_44); // good MyCompAltstep( var_11, var_22, var_33, var_44); // good MyCompAltstep( var_1, var_2, var_3, var_4); // error MyCompAltstep( 1.1, 2.8, 3.53, 4.94); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: component type .*---------------------------------------------------------------------* :xmp tab=0. Altstep: component type> module ModuleA { type component MyCT {} altstep MyAltstep ( MyCT par_1, // component type in MyCT par_2, out MyCT par_3, inout MyCT par_4 ) { var MyCT temp := par_1; [else] { par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } } function MyCompFunc () runs on MyCT { var MyCT temp, var_1, var_2, var_3, var_4; temp := MyCT.create; MyAltstep( var_1, var_2, var_3, var_4 ); // good MyAltstep( temp, temp, temp, temp); // good MyAltstep( MyCT.create, MyCT.create, temp, temp ); // good MyAltstep( MyCT.create, MyCT.create, MyCT.create, MyCT.create ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: component type .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: component type> module ModuleA { type component MyCT {} altstep MyCompAltstep ( MyCT par_1, // component type in MyCT par_2, out MyCT par_3, inout MyCT par_4 ) runs on MyCT { var MyCT temp := par_1; [else] { par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } } function MyCompFunc () runs on MyCT { var MyCT temp, var_1, var_2, var_3, var_4; temp := MyCT.create; MyCompAltstep( var_1, var_2, var_3, var_4 ); // good MyCompAltstep( temp, temp, temp, temp); // good MyCompAltstep( MyCT.create, MyCT.create, temp, temp ); // good MyCompAltstep( MyCT.create, MyCT.create, MyCT.create, MyCT.create ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: port type .*---------------------------------------------------------------------* :xmp tab=0. Altstep: port type> module ModuleA { type port MyPort message { inout charstring; } // port type type component MyCT { port MyPort port_1; port MyPort port_2; } altstep MyAltstep ( MyPort par_1, inout MyPort par_2 ) { [else] { par_1 := par_2; par_2 := par_1; } } altstep MyCompAltstep ( MyPort par_1, inout MyPort par_2 ) runs on MyCT { [else] { port_1 := par_1; par_1 := par_2; par_2 := port_1; } } function MyCompFunc ( MyPort par_1, inout MyPort par_2 ) runs on MyCT { MyAltstep( port_1, port_2 ); MyCompAltstep( port_1, port_2 ); } } (?im)\berror\b.+?Reference.+?expected.+?instead of.+?port_1 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2 (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: default .*---------------------------------------------------------------------* :xmp tab=0. Altstep: default> module ModuleA { altstep MyAltstep ( default par_1, // default in default par_2, out default par_3, inout default par_4 ) { var default temp := par_1; [else] { par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } } control { var default var_1, var_2, var_3, var_4; var default temp := null; MyAltstep( var_1, var_2, var_3, var_4 ); // good MyAltstep( temp, temp, temp, temp); // good MyAltstep( null, null, temp, temp); // good MyAltstep( null, null, null, null); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: default .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: default> module ModuleA { type component MyCT {} altstep MyCompAltstep ( default par_1, // default type in default par_2, out default par_3, inout default par_4 ) runs on MyCT { var default temp := par_1; [else] { par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } } function MyCompFunc () runs on MyCT { var default var_1, var_2, var_3, var_4; var default temp := null; MyCompAltstep( var_1, var_2, var_3, var_4 ); // good MyCompAltstep( temp, temp, temp, temp); // good MyCompAltstep( null, null, temp, temp); // good MyCompAltstep( null, null, null, null); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: timer .*---------------------------------------------------------------------* :xmp tab=0. Altstep: timer> module ModuleA { type component MyCT {} altstep MyAltstep ( timer par_1, inout timer par_2 ) { timer temp := 2.3; [else] { temp := par_1; // error par_1 := par_2; // error par_2 := temp; // error } } control { timer T1 := 2.9; timer T2 := 5.7; timer T3, T4; MyAltstep( T1, T2 ); // good MyAltstep( T3, T4 ); // good MyAltstep( 3.8, 4.5 ); // error } } (?im)\berror\b.+?Reference.+?expected.+?instead of.+?temp (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2 (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep: timer as non-mandatory parameter .*---------------------------------------------------------------------* :xmp tab=0. Altstep: timer as non-mandatory parameter> module ModuleA { type component MyCT {} altstep MyAltstep ( timer par_1 := 1.0, inout timer par_2 := 1.0) { [else] {} } } (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Altstep_runs_on: timer .*---------------------------------------------------------------------* :xmp tab=0. Altstep_runs_on: timer> module ModuleA { type component MyCT {} altstep MyCompAltstep ( timer par_1, inout timer par_2 ) runs on MyCT { timer temp := 2.3; [else] { temp := par_1; // error par_1 := par_2; // error par_2 := temp; // error } } function MyCompFunc () runs on MyCT { timer T1 := 2.9; timer T2 := 5.7; timer T3, T4; MyCompAltstep( T1, T2 ); // good MyCompAltstep( T3, T4 ); // good MyCompAltstep( 3.8, 4.5 ); // error } } (?im)\berror\b.+?Reference.+?expected.+?instead of.+?temp (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_1 (?im)\berror\b.+?Reference.+?expected.+?instead of.+?par_2 (?im)\berror\b.+?Reference.+?timer.+?expected.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: allowed in/out/inout .*---------------------------------------------------------------------* :xmp tab=0. Testcase: allowed in/out/inout> module ModuleA { type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer field } testcase MyTestcase ( integer par_11_1, // basic type in integer par_12_1, out integer par_13_1, inout integer par_14_1, octetstring par_11_2, // basic string type in octetstring par_12_2, out octetstring par_13_2, inout octetstring par_14_2, MySet par_21, // user-defined structured type in MySet par_22, out MySet par_23, inout MySet par_24, address par_31, // address in address par_32, out address par_33, inout address par_34, template MySet par_41, // template in template MySet par_42, out template MySet par_43, inout template MySet par_44, MyCT par_51, // component type in MyCT par_52, out MyCT par_53, inout MyCT par_54, default par_71, // default in default par_72, out default par_73, inout default par_74 ) runs on MyCT {} } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: allowed non-mandatory in/out/inout .*---------------------------------------------------------------------* :xmp tab=0. Testcase: allowed non-mandatory in/out/inout> module ModuleA { type port MyPort message { inout charstring; } type set MySet { float field1, boolean field2 optional } type record address { integer field } type component MyCT { const integer comp_const_i := 0; var integer comp_var_i := 0; const octetstring comp_const_o := '00'O; var octetstring comp_var_o := '00'O; const MySet comp_const_set := {field1 := 1.0, field2 := true}; var MySet comp_var_set := {field1 := 1.0, field2 := true}; const address comp_const_address := {5}; var address comp_var_address := {5}; port MyPort comp_port; timer comp_timer := 1.0; } testcase MyTestcase ( integer par_11_1 := comp_const_i, // basic type in integer par_12_1 := comp_const_i, out integer par_13_1 := comp_var_i, inout integer par_14_1 := comp_var_i, octetstring par_11_2 := comp_const_o, // basic string type in octetstring par_12_2 := comp_const_o, out octetstring par_13_2 := comp_var_o, inout octetstring par_14_2 := comp_var_o, MySet par_21 := comp_const_set, // user-defined structured type in MySet par_22 := comp_const_set, out MySet par_23 := comp_var_set, inout MySet par_24 := comp_var_set, address par_31 := comp_const_address, // address in address par_32 := comp_const_address, out address par_33 := comp_var_address, inout address par_34 := comp_var_address ) runs on MyCT {} } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: basic type .*---------------------------------------------------------------------* :xmp tab=0. Testcase: basic type> module ModuleA { type component MyCT {} testcase MyTestcase ( integer par_1, // basic type in integer par_2, out integer par_3, inout integer par_4 ) runs on MyCT { var integer temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } control { var integer var_1 := 1; var integer var_2 := 2; var integer var_3 := 3; var integer var_4 := 4; var integer var_11, var_22, var_33, var_44; execute ( MyTestcase( var_1, var_2, var_3, var_4) ); // good execute ( MyTestcase( var_11, var_22, var_33, var_44) ); // good execute ( MyTestcase( 1, 2, var_3, var_4) ); // good execute ( MyTestcase( 1, 2, 3, 4) ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: basic string type .*---------------------------------------------------------------------* :xmp tab=0. Testcase: basic string type> module ModuleA { type component MyCT {} testcase MyTestcase ( charstring par_1, // basic string type in charstring par_2, out charstring par_3, inout charstring par_4 ) runs on MyCT { var charstring temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } control { var charstring var_1 := "q"; var charstring var_2 := "w"; var charstring var_3 := "e"; var charstring var_4 := "r"; var charstring var_11, var_22, var_33, var_44; execute ( MyTestcase( var_1, var_2, var_3, var_4) ); // good execute ( MyTestcase( var_11, var_22, var_33, var_44) ); // good execute ( MyTestcase( "w", "e", var_3, var_4) ); // good execute ( MyTestcase( "q", "b", "5", "w") ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: user-defined type .*---------------------------------------------------------------------* :xmp tab=0. Testcase: user-defined type> module ModuleA { type component MyCT {} type set MySet { float field1, boolean field2 optional } testcase MyTestcase ( MySet par_1, // user-defined type in MySet par_2, out MySet par_3, inout MySet par_4 ) runs on MyCT { var MySet temp := { field1:=par_1.field1 } par_1.field1 := par_2.field1; par_2.field1 := par_3.field1; par_3.field1 := par_4.field1; par_4.field1 := temp.field1; } control { var MySet var_1 := { field1:=1.3 }; var MySet var_2 := { field1:=2.5 }; var MySet var_3 := { field1:=3.1 }; var MySet var_4 := { field1:=4.9 }; var MySet var_11, var_22, var_33, var_44; execute ( MyTestcase(var_1,var_2,var_3,var_4) ); // good execute ( MyTestcase(var_11,var_22,var_33,var_44) ); // good execute ( MyTestcase( {field1:=1.2, field2:=true}, // good {field1:=2.5, field2:=true}, var_3, var_4) ); execute ( MyTestcase( {field1:=1.2, field2:=true}, // error {field1:=2.5, field2:=true}, {field1:=3.6, field2:=true}, {field1:=4.1, field2:=true}) ); } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: address type .*---------------------------------------------------------------------* :xmp tab=0. Testcase: address type> module ModuleA { type component MyCT {} type record address { integer field } testcase MyTestcase ( address par_1, // address type in address par_2, out address par_3, inout address par_4 ) runs on MyCT { var address temp := { field:=par_1.field }; par_1.field := par_2.field; par_2.field := par_3.field; par_3.field := par_4.field; par_4.field := temp.field; } control { var address var_1 := { field:=1 }; var address var_2 := { field:=2 }; var address var_3 := { field:=3 }; var address var_4 := { field:=4 }; var address var_11, var_22, var_33, var_44; execute ( MyTestcase( {1}, {2}, var_3, var_4 ) ); // good execute ( MyTestcase( var_1, var_2, var_3, var_4 ) ); // good execute ( MyTestcase( var_11, var_22, var_33, var_44 ) ); // good execute ( MyTestcase( {1}, {2}, {3}, {4} ) ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: template .*---------------------------------------------------------------------* :xmp tab=0. Testcase: template> module ModuleA { type component MyCT {} testcase MyTestcase ( template float par_1, // template in template float par_2, out template float par_3, inout template float par_4 ) runs on MyCT { var float temp; temp := valueof ( par_1 ); temp := valueof ( par_2 ); temp := valueof ( par_3 ); temp := valueof ( par_4 ); par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } control { var float var_1 := 1.3; var float var_2 := 2.5; var float var_3 := 3.1; var float var_4 := 4.9; var template float var_11, var_22, var_33, var_44; execute ( MyTestcase( 1.1, 2.8, var_33, var_44) ); // good execute ( MyTestcase( var_11, var_22, var_33, var_44) ); // good execute ( MyTestcase( var_1, var_2, var_3, var_4) ); // error execute ( MyTestcase( 1.1, 2.8, 3.53, 4.94) ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: component type .*---------------------------------------------------------------------* :xmp tab=0. Testcase: component type> module ModuleA { type component MyCT {} testcase MyTestcase ( MyCT par_1, // component type in MyCT par_2, out MyCT par_3, inout MyCT par_4 ) runs on MyCT { var MyCT temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } control { execute ( MyTestcase( null, null, null, null) ); // good } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Testcase: default .*---------------------------------------------------------------------* :xmp tab=0. Testcase: default> module ModuleA { type component MyCT {} testcase MyTestcase ( default par_1, // default type in default par_2, out default par_3, inout default par_4 ) runs on MyCT { var default temp := par_1; par_1 := par_2; par_2 := par_3; par_3 := par_4; par_4 := temp; } control { var default var_1, var_2, var_3, var_4; var default temp := null; execute ( MyTestcase( var_1, var_2, var_3, var_4 ) ); // good execute ( MyTestcase( temp, temp, temp, temp) ); // good execute ( MyTestcase( null, null, temp, temp) ); // good execute ( MyTestcase( null, null, null, null) ); // error } } (?im)\berror\b.+?Reference.+?expected.+?out.+?parameter (?im)\berror\b.+?Reference.+?expected.+?inout.+?parameter (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: allowed in/out/inout .*---------------------------------------------------------------------* :xmp tab=0. Signature: allowed in/out/inout> module ModuleA { type component MyCT {} type set MySet { float field1, boolean field2 optional } type record address { integer field } signature MySigE(); // empty parameter list signature MySig ( integer par_11_1, // basic type in integer par_12_1, out integer par_13_1, inout integer par_14_1, octetstring par_11_2, // basic string type in octetstring par_12_2, out octetstring par_13_2, inout octetstring par_14_2, MySet par_21, // user-defined structured type in MySet par_22, out MySet par_23, inout MySet par_24, address par_31, // address in address par_32, out address par_33, inout address par_34, MyCT par_51, // component type in MyCT par_52, out MyCT par_53, inout MyCT par_54 ); } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: basic type .*---------------------------------------------------------------------* :xmp tab=0. Signature: basic type> module ModuleA { signature MySig ( integer par_1, // basic type in integer par_2, out integer par_3, inout integer par_4 ); type port MyPortType procedure { inout MySig } with { extension "internal" } type component MyComp { port MyPortType MyPort; } function MyFunc() runs on MyComp { var integer var_1 := 1; var integer var_2 := 2; var integer var_3 := 3; var integer var_4 := 4; var integer var_11, var_22, var_33, var_44; MyPort.call(MySig:{ var_1, var_2, var_3, var_4 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ var_11, var_22, var_33, var_44 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ 1, 2, var_3, var_4 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ 1, 2, 3, 4 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: basic string type .*---------------------------------------------------------------------* :xmp tab=0. Signature: basic string type> module ModuleA { signature MySig ( charstring par_1, // basic string type in charstring par_2, out charstring par_3, inout charstring par_4 ); type port MyPortType procedure { inout MySig } with { extension "internal" } type component MyComp { port MyPortType MyPort; } function MyFunc() runs on MyComp { var charstring var_1 := "q"; var charstring var_2 := "w"; var charstring var_3 := "e"; var charstring var_4 := "r"; var charstring var_11, var_22, var_33, var_44; MyPort.call(MySig:{ var_1, var_2, var_3, var_4 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ var_11, var_22, var_33, var_44 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ "s", "z", var_3, var_4 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ "p", "n", "c", "a" }, 20E-3 + 20E-3) { [] MyPort.getreply {} } } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: user-defined type .*---------------------------------------------------------------------* :xmp tab=0. Signature: user-defined type> module ModuleA { type set MySet { float field1, boolean field2 } signature MySig ( MySet par_1, // user-defined type in MySet par_2, out MySet par_3, inout MySet par_4 ); type port MyPortType procedure { inout MySig } with { extension "internal" } type component MyComp { port MyPortType MyPort; } function MyFunc() runs on MyComp { var MySet var_1 := { field1:=1.3 }; var MySet var_2 := { field1:=2.5 }; var MySet var_3 := { field1:=3.1 }; var MySet var_4 := { field1:=4.9 }; var MySet var_11, var_22, var_33, var_44; MyPort.call(MySig:{ var_1, var_2, var_3, var_4 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ var_11, var_22, var_33, var_44 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ {field1:=1.2, field2:=true}, {field1:=2.5, field2:=true}, var_3, var_4 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ {field1:=1.2, field2:=true}, {field1:=2.5, field2:=true}, {field1:=3.6, field2:=true}, {field1:=4.1, field2:=true} }, 20E-3 + 20E-3) { [] MyPort.getreply {} } } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: address type .*---------------------------------------------------------------------* :xmp tab=0. Signature: address type> module ModuleA { type record address { integer field } signature MySig ( address par_1, // address type in address par_2, out address par_3, inout address par_4 ); type port MyPortType procedure { inout MySig } with { extension "internal" } type component MyComp { port MyPortType MyPort; } function MyFunc() runs on MyComp { var address var_1 := { field:=1 }; var address var_2 := { field:=2 }; var address var_3 := { field:=3 }; var address var_4 := { field:=4 }; var address var_11, var_22, var_33, var_44; MyPort.call(MySig:{ var_1, var_2, var_3, var_4 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ var_11, var_22, var_33, var_44 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ {2}, {5}, var_3, var_4 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ {2}, {5}, {6}, {4} }, 20E-3 + 20E-3) { [] MyPort.getreply {} } } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: component type .*---------------------------------------------------------------------* :xmp tab=0. Signature: component type> module ModuleA { type component MyCT {} signature MySig ( MyCT par_1, // component type in MyCT par_2, out MyCT par_3, inout MyCT par_4 ); type port MyPortType procedure { inout MySig } with { extension "internal" } type component MyComp { port MyPortType MyPort; } function MyFunc() runs on MyComp { var MyCT temp, var_1, var_2, var_3, var_4; temp := MyCT.create; MyPort.call(MySig:{ var_1, var_2, var_3, var_4 }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ temp, temp, temp, temp }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ MyCT.create, MyCT.create, temp, temp }, 20E-3 + 20E-3) { [] MyPort.getreply {} } MyPort.call(MySig:{ MyCT.create, MyCT.create, MyCT.create, MyCT.create }, 20E-3 + 20E-3) { [] MyPort.getreply {} } } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::ParNotAllowedPassedByValueOrRef->Signature: special parameter .*---------------------------------------------------------------------* :xmp tab=0. Signature: special parameter> module ModuleA { signature MySig ( integer par_1, // basic type in integer par_2, out integer par_3, inout integer par_4 ); type port MyPortType procedure { inout MySig } with { extension "internal" } type component MyComp { port MyPortType MyPort; } function MyFunc() runs on MyComp { MyPort.call(MySig:{ -, 2, 3, 4 }, 20E-3 + 20E-3) { // good [] MyPort.catch {} } MyPort.call(MySig:{ 1, -, 3, 4 }, 20E-3 + 20E-3) { // good [] MyPort.catch {} } MyPort.call(MySig:{ 1, 2, -, 4 }, 20E-3 + 20E-3) { // good [] MyPort.catch {} } MyPort.call(MySig:{ 1, 2, 3, - }, 20E-3 + 20E-3) { // error [] MyPort.catch {} } } } (?im)\berror\b.+?Signature.+?incomplete.+?inout.+?parameter.+?par_4.+?missing (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3. group parametrization test 1 .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { group grp1(1) { type integer int1; } } (?im)\berror\b.+syntax error :exmp. .*---------------------------------------------------------------------* :h3. group parametrization test 2 .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { group(1) grp1 { type integer int1; } } (?im)\berror\b.+syntax error :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::FunctionReference invalid parametrization of type .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type function fntype(in integer i); control { fntype(11); } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::FunctionReference invalid parametrization of type 2 .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type function(in integer i) fntype; control { } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::FunctionReference invalid parametrization of variable .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type function fntype(in integer i); function fn(in integer i) { } control { var fntype f := refers(fn); f(11); } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::FunctionReference invalid parametrization of derefers .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type function fntype(in integer i); function fn(in integer i) { } control { var fntype f := refers(fn); execute(derefers(f)); } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::FunctionReference invalid parametrization of derefers 2 .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { function fn(in integer i) { } control { execute(derefers(refers(fn))); } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::FunctionReference invalid parametrization of derefers 3 .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type component my_component{}; function fn(in integer i) { } control { var my_component comp_var := my_component.create; comp_var.start(derefers(refers(fn))); } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::FunctionReference invalid parametrization of derefers 4 .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { function fn(in integer i) { } control { execute(derefers(null)); } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::FunctionReference invalid parametrization of derefers 5 .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type component my_component{}; function fn(in integer i) { } control { var my_component comp_var := my_component.create; comp_var.start(derefers(null)); } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Big integer parameters .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type component my_component { } function fn(in integer i, in integer j) runs on my_component { } testcase tc(in integer i) runs on my_component { fn(1234567891011121314151617181920, i) } control { execute(tc(1234567891011121314151617181920)) } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Parameterised template reference without parameter list1 .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type record my_type { integer field1, integer field2 }; template my_type t_orig (in integer pl_1 := 0, in integer pl_2 := 0) := { field1 := pl_1, field2 := pl_2 } function f() { var template my_type X1 := t_orig(1,2); var template my_type X2 := t_orig(); var template my_type X3 := t_orig; } } (?im)\bnotify\b.+?Generating.+?code :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Parameterised template reference without parameter list2 .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type record my_type { integer field1, integer field2 }; template my_type t_orig (in integer pl_1 := 0, in integer pl_2) := { field1 := pl_1, field2 := pl_2 } function f() { var template my_type X1 := t_orig(1,2); var template my_type X2 := t_orig(); var template my_type X3 := t_orig; } } (?im)\berror\b.+?Too.+?few.+?parameters.+?2.+?was.+?expected.+?instead.+?of.+?0 (?im)\berror\b.+?Reference.+?to.+?parameterized.+?definition.+?without.+?actual.+?parameter.+?list (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h1.Abbreviations .*---------------------------------------------------------------------* :list. :li D='ASN.1'.Abstract Syntax Notation 1 :li D='EDML'.Ericsson Document Markup Language :li D='SA'.Semantic Analyser :li D='TTCN-3'.Test and Test Control Notation version 3 :elist. .*---------------------------------------------------------------------* :h1.References .*---------------------------------------------------------------------* :list. :li D='[1]'.3/ETH/RUS-2003:0087 Uen :nl.Requirement Specification for TITAN's TTCN-3 Semantic Analyser :li D='[2]'.1/174 02-FCPCA 101 42 Uen :nl.Statement of Compliance for TITAN project :li D='[3]'.ETSI ES 201 873-1, v3.0.0 Mockup v1 (2004-03): :nl.Testing and Test Control Notation version 3., :nl.Part 1: TTCN-3 Core Language :elist. .*---------------------------------------------------------------------* :h1.Terminology .*---------------------------------------------------------------------* :list. :li D='TITAN'.Ericsson's TTCN-3 Test Environment :elist. :etext.