.****************************************************************************** .* Copyright (c) 2000-2016 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 .* .* Contributors: .* Balasko, Jeno .* Baranyi, Botond .* Bartha, Norbert .* Beres, Szabolcs .* Delic, Adam .* Forstner, Matyas .* Harai, Tibor .* Kovacs, Ferenc .* Palugyai, Sandor .* Pandi, Krisztian .* Szabados, Kristof .* Szabo, Janos Zoltan – initial implementation .* Szalai, Endre .* .******************************************************************************/ :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.17/152 91-CRL 113 200/3 Uen :rev.A :date.2015-04-27 :prep.ETH/XZ Jeno Balasko :appr.ETH/XZ (Gyula Koos) :checked.EKRISZA :title.Test description of the TTCN-3 Semantic Analyzer: Values, Value Lists, Ranges, Length, Dimensions, Durations and Subtyping :contents level=2. .*---------------------------------------------------------------------* :h1.Introduction .*---------------------------------------------------------------------* .*---------------------------------------------------------------------* :h2.Revision history .*---------------------------------------------------------------------* :xmp tab=2. REV DATE PREPARED CHANGE __________________________________________________ PA1 2005-02-17 ESNDPAL New document for TITAN R6 A 2005-03-18 ESNDPAL Approved after review B 2005-12-16 EKRISZA Updates for TITAN R6D C 2006-07-31 EDMDELI Updates for TITAN R6E D 2007-03-06 EJNOSZA Updates for TITAN R7A PE1 2008-01-22 EFERKOV Changes for TITAN R7C PE2 2008-01-25 ETHNBA Updates for TITAN R7C F 2009-06-11 EKRISZA Name correction G 2009-09-10 EKRISZA New tests for modified templates. H 2010-01-25 EKRISZA Refreshed version number I 2010-07-02 EKRISZA version update J 2010-07-02 EKRISZA version update K 2010-12-14 EKRISZA version update PL1 2011-02-23 ESZABRE Constant folding for indexes L 2011-02-23 EKRISZA removed line ending whitespaces M 2011-10-10 EKRISZA version update 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-6/x: Values, Value Lists, Ranges, Length, Dimensions, Durations and Subtyping. :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. .*---------------------------------------------------------------------* :h1.Test cases .*---------------------------------------------------------------------* Ref [1]: SA-6/x: Values, Value Lists, Ranges, Length, Dimensions, Durations and Subtyping .*---------------------------------------------------------------------* :h2.Subtyping .*---------------------------------------------------------------------* .*---------------------------------------------------------------------* :h3.Allowed subtyping .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/1. Strategy: TTCN-3 Core Language side:26, Table 3. :nl.All not allowed subtyping shall be tested based in the table. For all types in the table, there shall be one case when the subtyping is used directly with the type name and one for a named type that has a root type of the tested type, for example: :xmp tab=2. type integer i1 length(10); type i1 i2 length(10); :exmp. Both types are defined in one module. TODO: port, component and default tests are missing. NOTE: the address type is a user defined type so we won't test it. .*---------------------------------------------------------------------* :h4. Allowed subtyping - integer length .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type integer FaultyInt1 length(10); type integer Int; type Int FaultyInt2 length(4); } (?im)Length.+?subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - float length .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type float FaultyFloat1 length(10); type float Float; type Float FaultyFloat2 length(4); } (?im)Length.+?subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - boolean range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type boolean FaultyBool1 (false..true); type boolean Bool; type Bool FaultyBool2 (false..true); type boolean FaultyBool3 (true..true); type boolean FaultyBool4 (true..false); } (?im)Range.+?subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - boolean length .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type boolean FaultyBool1 length(1); type boolean Bool; type Bool FaultyBool2 length(2); } (?im)Length.+?subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - objid range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type objid FaultyObjid1 (objid{0 1 2} .. objid{0 1 4}); type objid Objid; type Objid FaultyObjid2 (objid{0 1 2} .. objid{0 1 4}); type objid FaultyObjid3 (objid{0 2 4} .. objid{0 1 2}); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - objid length .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type objid FaultyObjid1 length(3); type objid Objid; type Objid FaultyObjid2 length(4) } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - verdicttype range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type verdicttype FaultyVerdict1 (pass..error); type verdicttype Verdict; type verdicttype FaultyVerdict2 (pass..fail); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - verdicttype length .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type verdicttype FaultyVerdict1 length(1); type verdicttype Verdict; type Verdict FaultyVerdict2 length(2); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - bitstring range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type bitstring FaultyBS1 ('0000'B .. '0111'B); type bitstring BS; type BS FaultyBS2 ('1000'B .. '1111'B); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - hexstring range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type hexstring FaultyHS1 ('000'H .. 'A53'H); type hexstring HS; type HS FaultyHS2 ('100'H .. 'FFF'H); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - octetstring range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type octetstring FaultyOS1 ('0000'O .. 'AB53'O); type octetstring OS; type OS FaultyOS2 ('00'O .. '7F'O); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - record range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type record Record { integer intField, float floatField } const Record c_lower := {0, 0.0}; const Record c_upper := {10, 10.0}; type Record FaultyRecord1 (0 .. 10); type Record FaultyRecord2 (c_lower .. c_upper); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - record length .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type record Record { integer intField, float floatField } type Record FaultyRecord length(12); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - record of range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type record of integer RecordOfInt; const RecordOfInt c_lower := {0, 0}; const RecordOfInt c_upper := {10, 10}; type RecordOfInt FaultyRecordOfInt1 (0 .. 10); type RecordOfInt FaultyRecordOfInt2 (c_lower .. c_upper); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - set range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type set Set { integer intField, float floatField } const Set c_lower := {0, 0.0}; const Set c_upper := {10, 10.0}; type Set FaultySet1 (0 .. 10); type Set FaultySet2 (c_lower .. c_upper); } (?im)Value.+?list.+?notation.+?cannot.+?used (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - set length .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type set Set { integer intField, float floatField } type Set FaultySet length(12); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - set of range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type set of integer SetOfInt; const SetOfInt c_lower := {0, 0}; const SetOfInt c_upper := {10, 10}; type SetOfInt FaultySetOfInt1 (0 .. 10); type SetOfInt FaultySetOfInt2 (c_lower .. c_upper); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - enumerated range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type enumerated Enum { EnumValue0(0), EnumValue1(1), EnumValue2(2), EnumValue3(3) }; type Enum FaultyEnum1 (0..2); type Enum FaultyEnum2 (EnumValue0..EnumValue2); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - enumerated length .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type enumerated Enum { EnumValue0(0), EnumValue1(1), EnumValue2(2), EnumValue3(3) }; type Enum FaultyEnum length(4); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - union range .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type union Union { integer intField, float floatField } const Union c_lower := {intField := 0}; const Union c_upper := {intField := 10}; type Union FaultyUnion1 (0 .. 10); type Union FaultyUnion2 (c_record_lower .. c_record_upper); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. Allowed subtyping - union length .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type union Union { integer intField, float floatField } type Union FaultyUnion length(8); } (?im)subtyping.+?not.+?allowed (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4. TTCN-3::FunctionReference->Subtyping: length .*---------------------------------------------------------------------* :xmp tab=0. Subtyping: length> module Temp { type function fntype() length(10); } (?im)\berror\b.+?syntax.+?error (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h4. TTCN-3::FunctionReference->Subtyping: range .*---------------------------------------------------------------------* :xmp tab=0. Subtyping: range> module Temp { function fn1() { } function fn2() { } function fn3() { } type function fntype() (fn1..fn3); } (?im)\berror\b.+?syntax.+?error (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.True subset .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/2. Strategy: the values in the list shall be a true subset of the values defined by the root type All occurances shall be tested, where such a notation can be used. .*---------------------------------------------------------------------* :h3.Mixing different subset notations .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/3. Strategy: Mixing different subset notations is not allowed for the specific type All occurances shall be tested, where such a notation can be used. .*---------------------------------------------------------------------* :h3.Invalid subset notation .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/4. Strategy: the value notation used for subtyping is invalid due to: :list. :li D='-'.duplicated element in a list of values :li D='-'.ranges/lists have intersection (common elements) :li D='-'.lower boundary is greater than upper boundary :li D='-'.the boundaries shall evaluate to valid character positions according to the coded character set table(s) of the type (for example the given position shall not be empty) :elist. All occurances shall be tested, where such a notation can be used. .*---------------------------------------------------------------------* :h2.Value notations .*---------------------------------------------------------------------* .*---------------------------------------------------------------------* :h3.Mixing value notations .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/5. Strategy: check that mixing assignment and value notations are detected for all types that allow the usage of at least one of the notations (that is value, assignment). All occurances shall be tested, where such a notation can be used. Tested: - record and set in function TODO: only a couple of TCs are written, this shall be implemented ones the SA performs the checking and not the parser. .*---------------------------------------------------------------------* :h4.Mixing value notations - assignment notation in value list (record const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record Record { integer I, float F, charstring CS } function MyFunc() { // NOTE: catched by the parser // TR 709: Not allowed value notation reporting var Record FaultyRecord := { 10, F:= 0.0, "error" }; } } (?im)\berror\b.+?syntax.+?error.+?unexpected.+?:= :exmp. .*---------------------------------------------------------------------* :h4.Mixing value notations - assignment notation in value list (set const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setType { integer I, float F, charstring CS } function MyFunc() { // NOTE: catched by the parser // TR 709: Not allowed value notation reporting const setType s := { 10, F:= 0.0, "error" }; } } (?im)\berror\b.+?syntax.+?error.+?unexpected.+?:= :exmp. .*---------------------------------------------------------------------* :h3.Allowed value notations .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/6. Startegy: All occurances shall be tested, where such a notation can be used: :list. :li D='-'.in constants and variables :li D='-'.in templates (static, modified, dynamic) :elist. All elements in the tables below are tested in 2 situations (whenever it is allowed): in module definition part and within a function. :xmp tab=0. :nl.for constants and variables: :nl.================================================================================= :nl. type assignment | value list | array | value assignment notation :nl.================================================================================= :nl.basic types T T O T :nl.--------------------------------------------------------------------------------- :nl.string types T T - T :nl.--------------------------------------------------------------------------------- :nl.record - - O O :nl.--------------------------------------------------------------------------------- :nl.set - O O O :nl.--------------------------------------------------------------------------------- :nl.union - T O O :nl.--------------------------------------------------------------------------------- :nl.record of T - - O :nl.--------------------------------------------------------------------------------- :nl.set of T - - O :nl.--------------------------------------------------------------------------------- :nl.enumerated T T O T :nl.--------------------------------------------------------------------------------- :nl. :nl.for templates and dynamic templates: :nl.================================================================================= :nl. type assignment | value list | array | value assignment notation :nl.================================================================================= :nl.basic types T T O T :nl.--------------------------------------------------------------------------------- :nl.string types T T - T :nl.--------------------------------------------------------------------------------- :nl.record - - O O :nl.--------------------------------------------------------------------------------- :nl.set - O O O :nl.--------------------------------------------------------------------------------- :nl.union - T O O :nl.--------------------------------------------------------------------------------- :nl.record of T - - O :nl.--------------------------------------------------------------------------------- :nl.set of T - - O :nl.--------------------------------------------------------------------------------- :nl.enumerated T T O T :nl.--------------------------------------------------------------------------------- :nl. :nl.for modified templates: :nl.================================================================================= :nl. type assignment | value list | value assignment notation :nl.================================================================================= :nl.basic types T T T :nl.--------------------------------------------------------------------------------- :nl.string types T T T :nl.--------------------------------------------------------------------------------- :nl.record - - O :nl.--------------------------------------------------------------------------------- :nl.set - O O :nl.--------------------------------------------------------------------------------- :nl.union - T O :nl.--------------------------------------------------------------------------------- :nl.record of T - - :nl.--------------------------------------------------------------------------------- :nl.set of T - O :nl.--------------------------------------------------------------------------------- :nl.enumerated T T T :nl.--------------------------------------------------------------------------------- :nl.(array notation is not used for modified templates) :nl. :exmp. basic types: integer, float, boolean, objid, verdicttype, anytype, address, port, component, default string types: bitstring, hexstring, charstring, octetstring, universal charstring T: type compatibility error, shall not be tested here :nl.O: semantic error, shall be tested here :nl.-: allowed, so cannot be negative-tested Tested: The upper tables for: :list. :li D='-'.constants in definition part and function :li D='-'.templates in definition part :elist. TODO: - Dinamic template tests are not ready. NOTE: :nl.- type "anytype" haven't implemented yet. Can't use array notation for type "port". :nl.- the type "address" in the TITAN implementation is a user defined type, so we won't test it. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const integer in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ const integer r:= 233; const integer f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const integer in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ function myFunct(){ const integer r:= 233; const integer f:= r[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template integer in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template integer r:= 233; template integer f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const float in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ const float r:= 23.3; const float f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ function myFunct(){ const float r:= 23.3; const float f:= r[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template float in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template float r:= 23.3; template float f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const boolean in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ const boolean r:= true; const boolean f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ function myFunct(){ const boolean r:= true; const boolean f:= r[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template boolean in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template boolean r:= true; template boolean f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const objid in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ const objid r:= objid{ 0 4 }; const objid f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const objid in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ function myFunct(){ const objid r:= objid{ 0 4 }; const objid f:= r[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template objid in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template objid r:= objid{ 0 4 }; template objid f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const verdicttype in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ const verdicttype r:= pass; const verdicttype f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const verdicttype in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ function myFunct(){ const verdicttype r:= pass; const verdicttype f:= r[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template verdicttype in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template verdicttype r:= pass; template verdicttype f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const component in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type component c{ }; const c r:= null; const c f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const component in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type component c{ }; function myFunct(){ const c r:= null; const c f:= r[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template component in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type component c{ }; template c r:= null; template c f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const default in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ const default r:= null; const default f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const default in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ function myFunct(){ const default r:= null; const default f:= r[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template default in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template default r:= null; template default f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template bitstring in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template bitstring r:= '01011'B; template bitstring f:= r[0]; } (?im)type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bCode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template hexstring in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template hexstring r:= 'AB01D'H; template hexstring f:= r[0]; } (?im)type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template octetstring in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template octetstring r:= '000000'O; template octetstring f:= r[0]; } (?im)type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template charstring in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template charstring r:= "aiyyo"; template charstring f:= r[0]; } (?im)type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template universal charstring in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ template universal charstring r:= "aiyyo" & char( 0, 0, 1, 113) & "yo"; template universal charstring f:= r[0]; } (?im)type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const record in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record Record { integer I, float F optional, charstring CS } const Record r := { 1, 0.0, "error" }; const integer f := r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const record in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record Record { integer I, float F optional, charstring CS } function MyFunc() { const Record r := { 1, 0.0, "aiyyo" }; const integer f := r[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template record in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer I, float F, charstring CS } template recT r := { I:= 1, F:= 0.0, CS:= "aiyyo" }; template recT f := r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (const record in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type record recT{ integer f1, float f2, charstring f3 } const recT f:={ [1]:= 1, [2]:= 0.9, [3]:= "aiyyo" } } (?is)\berror: Indexed assignment notation cannot be used for record type `@x.recT' :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (const record in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type record recT{ integer f1, float f2, charstring f3 } function MyFunc() { const recT f:={ [1]:= 1, [2]:= 0.9, [3]:= "pass" } } } (?is)\berror: Indexed assignment notation cannot be used for record type `@x.recT' :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (template record in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type record recT{ integer f1, float f2, charstring f3 } template recT f:={ [1]:= 1, [2]:= 0.9, [3]:= "aiyyo" } } (?im)\berror\b.+?assignment.+?notation.+?with.+?array.+?indices.+?cannot.+?be.+?used.+?for.+?record.+?type (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (timer-array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ function MyFunc() { timer timerarray[3] := {[0] := 1, [1] := 2, [2] := 3}; } } (?is)\bA value or expression of type float was expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (port-array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type port myport message{inout charstring}; type component self_comp{ port myport ports[3]; } function MyFunc() runs on self_comp{ ports := {[0] := 1.0, [1] := 2.0, [2] := 3.0}; } } (?im)\berror\b.+?Reference.+?to.+?a.+?variable.+?or.+?template.+?variable.+?was.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (modified template record in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type record recT{ integer f1, float f2, charstring f3 } template recT r:={ f1:= 1, f2:= 0.9, f3:= "aiyyo" } template recT f modifies r:= { [0]:= 1, [2]:= 0.9 }; } (?im)\berror\b.+?assignment.+?notation.+?with.+?array.+?indices.+?cannot.+?be.+?used.+?for.+?record.+?type (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value list notation (modified template record in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type record recT{ integer f1, float f2, charstring f3 } template recT r:={ f1:= 1, f2:= 0.9, f3:= "aiyyo" } template recT f modifies r:= ({ f1:= 1, f2:= 0.9 }, { f1 := 1, f2 := 0.9, f3 := "pppp" }); } (?im)\berror\b.+?field.+?f3.+?is.+?missing.+?from.+?template.+?for.+?record.+?type (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - complement value list notation (modified template record in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type record recT{ integer f1, float f2, charstring f3 } template recT r:={ f1:= 1, f2:= 0.9, f3:= "aiyyo" } template recT f modifies r:= complement({ f1:= 1, f2:= 0.9 }, { f1:= 1, f2:= 0.9, f3 := "pppp" }); } (?im)\berror\b.+?field.+?f3.+?is.+?missing.+?from.+?template.+?for.+?record.+?type (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value list (const set in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set Set { integer I, float F, charstring CS } const Set s := { 3.14, "error", 9 }; } (?im)value.+?list.+?notation.+?cannot.+?be.+?used (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value list (const set in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set Set { integer I, float F, charstring CS } function MyFunc() { const Set s := { 3.14, "error", 9 }; } } (?im)value.+?list.+?notation.+?cannot.+?be.+?used (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value list (template set in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set Set { integer I, float F, charstring CS } template Set s := { 3.14, "error", 9 }; } (?im)Value.+?list.+?notation.+?not.+?allowed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value list (modified template set in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT { integer I, float F, charstring CS } template setT s:= { F:= 3.14, CS:= "aiyyo", I:= 9 }; template setT f modifies s:= { 0, 8.8, "gerappa" }; } (?im)Value.+?list.+?notation.+?not.+?allowed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const set in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set Set { integer I, float F optional, charstring CS } const Set cSet := { I:= 1, F:= 0.0, CS:= "error" }; const integer FaultyField := cSet[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const set in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set Set { integer I, float F optional, charstring CS } function MyFunc() { const Set cSet := { I:= 1, F:= 0.0, CS:= "error" }; const integer FaultyField := cSet[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template set in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set Set { integer I, float F optional, charstring CS } template Set cSet := { I:= 1, F:= 0.0, CS:= "error" }; template integer FaultyField := cSet[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (const set in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type set setT{ integer f1, float f2, charstring f3 } const setT f:={ [1]:= 1, [2]:= 0.9, [3]:= "pass" } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (template set in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type set setT{ integer f1, float f2, charstring f3 } template setT f:={ [1]:= 1, [2]:= 0.9, [3]:= "pass" } } (?im)\berror\b.+?assignment.+?notation.+?with.+?array.+?indices.+?cannot.+?be.+?used.+?for.+?set.+?type (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (modified template set in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type set setT{ integer f1, float f2, charstring f3 } template setT r:={ f1:= 1, f2:= 0.9, f3:= "aiyyo" } // TR 711: A nonexistent reference is reported only once template setT f modifies r:= { [0]:= 1, [2]:= 0.9 }; } (?im)\berror\b.+?assignment.+?notation.+?with.+?array.+?indices.+?cannot.+?be.+?used.+?for.+?set.+?type (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const union in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union u { integer f_int, float f_float } const u r := { f_int:=1 }; const u f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union u { integer f_int, float f_float } function myFunct(){ const u r := { f_int:=1 }; const u f:= r[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template union in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union u { integer f_int, float f_float } template u r := { f_int:=1 }; template u f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (const union in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type union uniT{ integer f1, float f2, charstring f3 } const uniT f:={ [1]:= 1 } } (?is)\berror: union value was expected for type `@x.uniT' (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (const union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type union uniT{ integer f1, float f2, charstring f3 } function myFunct(){ const uniT f:={ [1]:= 1 } } } (?is)\berror: union value was expected for type `@x.uniT' (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (template union in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type union uniT{ integer f1, float f2, charstring f3 } // TR 710: Incorrect error message template uniT f:={ [1]:= 1 } } (?im)\berror\b.+?assignment.+?notation.+?with.+?array.+?indices.+?cannot.+?be.+?used.+?for.+?union.+?type (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - value assignment notation (modified template union in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union u { integer f_int, float f_float } template u r := { f_int:=1 }; // TR 710: Incorrect error message template u f modifies r:= { [0]:= 2 }; } (?im)\berror\b.+?assignment.+?notation.+?with.+?array.+?indices.+?cannot.+?be.+?used.+?for.+?union.+?type (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const enumerated in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enum { ONE(1), TWO(2), THREE(3) }; const enum r:= ONE; const enum f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (const enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enum { ONE(1), TWO(2), THREE(3) }; function myFunct(){ const enum r:= ONE; const enum f:= r[0]; } } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed value notations - array notation (template enumerated in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enum { ONE(1), TWO(2), THREE(3) }; template enum r:= ONE; template enum f:= r[0]; } (?im)Type.+?cannot.+?be.+?indexed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value notations - value assignment notation (timer-array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x{ function MyFunc() { timer timerarray[3] := {[0] := 1.0, [1] := 2.0, [2] := 3.0, [3] := 4.0}; timer timerarray2[3] := {[0.0] := 1.0, [1] := 2.0, [2] := 3.0}; timer timerarray3[3] := {[0] := 1.0, [1] := 2.0}; timer timerarray4[3] := {[-1] := 1.0, [0] := 2.0, [1] := 3.0}; timer timerarray5[3] := {[0] := 1.0, [0] := 2.0, [1] := 3.0}; } } (?im)\berror: Array index overflow: the index value must be at most `2' instead of `3' (?im)\berror: A value or expression of type integer was expected (?im)\berror: Array index underflow: the index value must be at least `0' instead of `-1' (?im)\berror: Duplicate index value `0' for timer array elements `2' and `1' (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value notations - value assignment notation (index out of bound) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type integer myIntType[3]; function MyFunc() { var myIntType myintarray := {[0] := 0, [1] := 1, [2]:= 2}; var myIntType myintarray2 := {[0] := 0, [1] := 1}; var myIntType myintarray3 := {[0] := 0, [1] := 1, [2]:= 2, [2] := 3}; var integer i := 2; var myIntType myintarray4 := {[i] := 0, [i] := 1, [i]:= 2}; } } (?im)\berror: Duplicate index value `2' for components `4' and `3' (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h4.Value notations - value assignment notation (negative index is used) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type integer myIntType[3]; function MyFunc() { var myIntType myintarray := {[0] := 0, [-1] := 1, [2]:= 2}; var myIntType myintarray2 := {[0.0] := 0, [1.0] := 1, [2.3]:= 2}; var integer i := -56; var myIntType myintarray3 := {[i] := 0, [i] := 1, [i]:= 2}; } } (?im)\berror: Array index underflow: the index value must be at least `0' instead of `-1' (?im)\berror: A value or expression of type integer was expected (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value notations - value assignment notation (structured types) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type integer myIntType[3]; type record myTestRec { myIntType intlist, integer myint } type record of myTestRec myTestRecList; type record of integer myIntegerList; type record myTestRec2 { myIntegerList myintegerlist, integer myint } function MyFunc() { var myTestRecList mytestreclist := {[0] := {intlist := {[0]:=0, [1]:= 1, [2]:=2}, myint:= 1}}; var myTestRecList mytestreclist2 := {[0] := {intlist := {[0]:=0, [1]:= 1, [-2]:=2}, myint:= 1}}; var myTestRecList mytestreclist3 := {[0] := {intlist := {[0]:=0, [1]:= 1, [2.0]:=2}, myint:= 1}}; var myTestRecList mytestreclist4 := {[0] := {intlist := {[0]:=0, [1]:= 1}, myint:= 1}}; var myTestRecList mytestreclist5 := {[0] := {intlist := {[0]:=0, [1]:= 1, [2]:=2, [3] := 3}, myint:= 1}}; var myTestRecList mytestreclist6 := {[0] := {intlist := {[0]:=0, [1]:= 1, [1]:=2}, myint:= 1}}; var myTestRec2 mytestrec := {myintegerlist := {[0]:= 0, [1] := 1, [2] := 2}, myint := 1}; var myTestRec2 mytestrec2 := {myintegerlist := {[0.0]:= 0, [1] := 1, [2] := 2}, myint := 1}; var myTestRec2 mytestrec3 := {myintegerlist := {[0]:= 0, [-1] := 1, [2] := 2}, myint := 1}; var myTestRec2 mytestrec4 := {myintegerlist := {[0]:= 0, [1] := 1, [1] := 2}, myint := 1}; } } (?im)\berror: Array index underflow: the index value must be at least `0' instead of `-2' (?im)\berror: A value or expression of type integer was expected (?im)\berror: Array index overflow: the index value must be at most `2' instead of `3' (?im)\berror: Duplicate index value `1' for components `3' and `2' (?im)\berror: A non-negative integer value was expected for indexing type `@x.myIntegerList' instead of `-1' (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value notations - value assignment notation (modify template) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type record of integer MyIntType; template MyIntType T1 := {0, 1, 2}; template MyIntType T2 modifies T1:= {[0] := 1, [0]:= 5}; template MyIntType T3 modifies T1:= {[0] := 1, [-5]:= 5}; } (?im)\berror: Duplicate index value `0' for components `2' and `1' (?im)\berror: A non-negative integer value was expected for indexing type `@x.MyIntType' instead of `-5' (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value notations - value assignment notation (modify template2) .*---------------------------------------------------------------------* :xmp tab=0. module x{ type integer IntType[3]; type record of integer MyIntType; template MyIntType T1 := {0, 1, 2}; template MyIntType T2 modifies T1:= {[0.1] := 1, [1]:= 5}; template MyIntType T3 modifies T1:= {[0] := 1, [1.0]:= 5}; function MyFunc() { var IntType myintarray := {['00'O] := 0, [1.5] := 1, [2]:= 2}; } } (?im)\bA value or expression of type integer was expected (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3. Value notations - Value notations shall assign a value to a specific element only once .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/7. Startegy: In one value notation an element can get value only once. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.record and set constants in definition part and function :li D='-'.record modified template in definition part :li D='-'.enumerated type in definition part :elist. .*---------------------------------------------------------------------* :h4.Value notations - A value notation shall assign a value to a specific element only once - duplicated element assignment in record (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record Record { integer I, float F, charstring CS } const Record wrongRecord := { I:= 1, F:= 0.0, CS:= "error", F:= 2.0 }; } (?im)Duplicate.+?record.+?field (?im)Field.+?already.+?given (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value notations - A value notation shall assign a value to a specific element only once - duplicated element assignment in record (const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record Record { integer I, float F, charstring CS } function MyFunc() { const Record wrongRecord := { I:= 1, F:= 0.0, CS:= "error", F:= 2.0 }; } } (?im)Duplicate.+?record.+?field (?im)Field.+?already.+?given (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value notations - A value notation shall assign a value to a specific element only once - duplicated element assignment in set (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set Set { integer I, float F, charstring CS } const Set s := { F:= 0.0, I:= 3, CS:= "error", F:= 9.0 }; } (?im)Duplicate.+?set.+?field (?im)Field.+?already.+?given (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value notations - A value notation shall assign a value to a specific element only once - duplicated element assignment in record of (modified template in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; template rofT temp:= { 1, 2, 3, 4, 5}; template rofT modTemp modifies temp:= { [2]:= 7, [3]:= 10, [2]:= 14 }; } (?im)\berror\b.+?Duplicate.+?index.+?value (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value notations - A value notation shall assign a value to a specific element only once - duplicated element assignment in set (const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set Set { integer I, float F, charstring CS } function MyFunc() { const Set s := { F:= 0.0, I:= 3, CS:= "error", F:= 9.0 }; } } (?im)Duplicate.+?set.+?field (?im)Field.+?already.+?given (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value notations - A value notation shall assign a value to a specific element only once - duplicated element assignment in enumerated type (in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated Enum { ONE(1), TWO(2), THREE(1) }; } (?im)Duplicate.+?value.+?enumeration (?im)already.+?assigned (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h2.Allowed values (each evaluated expression shall conform to the context-specific rules) .*---------------------------------------------------------------------* .*---------------------------------------------------------------------* :h3.Allowed values of an object identifier .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/8. Startegy: in assignment of an object identifier the first two elements have to be defined. We can define these elements in three ways: :list. :li D='-'.with numbers : { 0 4 ...} :li D='-'.with identifiers : { itu_t identified_organization ...} :li D='-'.with both of them : { itu_t(0) identified_organization(4) ...} :elist. For more information see the ITU-T X.660. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.wrong first number in definition part and function :li D='-'.wrong identifier in definition part and function :elist. .*---------------------------------------------------------------------* :h4.Allowed values of an object identifier - wrong first number (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const objid o:= objid{ 6 1 0 0 }; } (?im)value.+?first.+?OBJECT.+?IDENTIFIER.+?must.+?between.+?instead (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed values of an object identifier - wrong first number (const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function MyFunc() { const objid o:= objid{ 6 1 0 0 }; } } (?im)value.+?first.+?OBJECT.+?IDENTIFIER.+?must.+?between.+?instead (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed values of an object identifier - wrong identifier (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const objid o:= objid{ ecci identified_organization ehh(0) behh(0) }; } (?im)error.+?no.+?local.+?imported.+?definition (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed values of an object identifier - wrong identifier (const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function MyFunc() { const objid o:= objid{ ecci identified_organization ehh(0) behh(0) }; } } (?im)error.+?no.+?local.+?imported.+?definition (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.Allowed values of an universal charstring .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/9. Strategy: for information see the ISO/IEC 10646. :nl. First number: 0-128 :nl. Second number: 0-255 :nl. Third number: 0-255 :nl. Fourth number: 0-255 :nl. Only numbers are allowed. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.wrong first number in definition part and function :li D='-'.operator in definition part :li D='-'.constant in function :elist. .*---------------------------------------------------------------------* :h4.Allowed values of an universal charstring - wrong first number (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const universal charstring f:= "aiyyo" & char( 130, 25, 10, 25) & "gerappa"; } (?im)\berror\b.+?first.+?number.+?must.+?within.+?range (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed values of an universal charstring - wrong first number (const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function MyFunc() { const universal charstring f:= "aiyyo" & char( 130, 25, 10, 25) & "gerappa"; } } (?im)\berror\b.+?first.+?number.+?must.+?within.+?range (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed values of an universal charstring - operator (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const universal charstring f:= "aiyyo" & char( 13, 25+32, 10, 25) & "gerappa"; } (?im)\berror\b.+?syntax.+?error.+?unexpected.+?\+ (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed values of an universal charstring - constant (const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer i:= 12; function MyFunc() { const universal charstring f:= "aiyyo" & char( i, 25, 10, 25) & "gerappa"; } } (?im)\berror\b.+?syntax.+?error.+?unexpected.+?identifier (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Function reference - incompatible types .*---------------------------------------------------------------------* :xmp tab=0. module x { type function fntype1(); type function fntype2(); function MyFunc() { var fntype1 f1; var fntype2 f2; if (f1==f2) { } } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h4.Allowed values of an function reference - 1 .*---------------------------------------------------------------------* :xmp tab=0. module x { type function fntype(); function fn1(integer i) { } function fn2() { } function MyFunc() { var fntype f1 := refers(fn1); var fntype f2 := refers(fn2); } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h4.Allowed values of an function reference - 2 .*---------------------------------------------------------------------* :xmp tab=0. module x { type function fntype(); function fn1() { } function fn2() return charstring { return ""; } function MyFunc() { var fntype f1:= refers(fn1); var fntype f2:= refers(fn2); } } (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h4.Allowed values of an function reference - 3 .*---------------------------------------------------------------------* :xmp tab=0. module x { type function fntype(integer a); function fn1(integer b) { } function fn2(integer a) { } function MyFunc() { var fntype f1:= refers(fn1); var fntype f2:= refers(fn2); } } (?im)\bwarning\b.+?name.+?of.+?parameter.+?not.+?the.+?same (?is)\berror: (?im)\bnotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b :exmp. .*---------------------------------------------------------------------* :h3.Allowed values of an index when accessing a single element of a string value .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/10. Strategy: indexing of string values has to beginning with 0. So shall not use negative numbers or higher numbers than size(string)-1. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.higher number in index than the size in definition part and function :li D='-'.negative index in definition part and function :elist. .*---------------------------------------------------------------------* :h4.String indexing - indexing begin with zero (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring CS:="WRONG"; const charstring wrongCS := CS[5]; } (?im)Index.+?overflow.+?string.+?element (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.String indexing - indexing begin with zero (const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function MyFunc() { const charstring CS:="WRONG"; const charstring wrongCS := CS[5]; } } (?im)Index.+?overflow.+?string.+?element (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.String indexing - indexing must be non-negative (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring CS:="WRONG"; const charstring wrongCS := CS[-1]; } (?im)non-negative.+?value.+?expected.+?instead of.+?indexing.+?string.+?element (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.String indexing - indexing must be non-negative (const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function MyFunc() { const charstring CS:="WRONG"; const charstring wrongCS := CS[-1]; } } (?im)non-negative.+?value.+?expected.+?instead of.+?indexing.+?string.+?element (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.Omitting mandatory fields .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/11. Strategy: shall not omitting mandatory fields All occurances shall be tested, where such a notation can be used. Tested: - record and set fields in definition part and function .*---------------------------------------------------------------------* :h4.Omitting mandatory fields - wrong optional record field (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record Record { integer I, float F optional, charstring CS } const Record r := { omit, 0.0, "error" }; } (?im)omit.+?not.+?allowed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Omitting mandatory fields - referencing unbound (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record Record { integer a, integer b } const Record c_R := { b := 1 }; const integer c_i := c_R.a } (?im)Reference.+?unbound.+?field (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Omitting mandatory fields - wrong optional record field (const in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record Record { integer I, float F optional, charstring CS } function MyFunc() { const Record r := { omit, 0.0, "error" }; } } (?im)omit.+?not.+?allowed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Omitting mandatory fields - wrong optional set field (const in def. part) .*---------------------------------------------------------------------* :xmp tab=0. (const in def. part) module x { type set Set { integer I, float F optional, charstring CS } const Set s := { F:= 0.0, I:= omit, CS:= "error" }; } (?im)omit.+?not.+?allowed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Omitting mandatory fields - wrong optional set field (const in function) .*---------------------------------------------------------------------* :xmp tab=0. (const in function) module x { type set Set { integer I, float F optional, charstring CS } function MyFunc() { const Set s := { F:= 0.0, I:= omit, CS:= "error" }; } } (?im)omit.+?not.+?allowed (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.Values are not constants or literals in subtype-specifications .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/12. Strategy: values in list, range and string length shall be initialized with constants or literal values. So it shall not contains functions returned with random values, and hand-made functions neither. See the table 3, side 26. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.inner random and hand-made functions in charstring length :li D='-'.inner random and hand-made functions in bitstring length-range :li D='-'.both type of functions in bitstring length-range :li D='-'.inner random and hand-made functions in integer-range :li D='-'.both type of functions in float-range :li D='-'.inner random and hand-made functions in integer-list :li D='-'.both type of functions in float-list :elist. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - rnd() in length (charstring ) .*---------------------------------------------------------------------* :xmp tab=0. module x { type charstring myCharType length( float2int(rnd()) ); } (?im)error.+?evaluable.+?constant.+?value.+?expected.+?instead.+?of.+?operation (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - hand-made function in length (charstring ) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct() return integer{ return 5; } type charstring myCharType length( myFunct() ); } (?im)error.+?Reference.+?constant.+?expected.+?instead (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - rnd() in length range (bitstring ) .*---------------------------------------------------------------------* :xmp tab=0. module x { type charstring myCharType length( float2int(rnd()) .. 5 ); } (?im)error.+?evaluable.+?constant.+?value.+?expected.+?instead.+?of.+?operation (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - hand-made function in length range (bitstring ) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct() return integer{ return 5; } type charstring myCharType length( 2 .. myFunct()); } (?im)error.+?Reference.+?constant.+?expected.+?instead (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - both types of functions in length range (bitstring ) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct() return integer{ return 5; } type charstring myCharType length( float2int(rnd()) .. myFunct()); } (?im)error.+?evaluable.+?constant.+?value.+?expected.+?instead.+?of.+?operation (?im)error.+?Reference.+?constant.+?expected.+?instead (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - rnd() in range (integer ) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myIntType ( float2int(rnd()) .. 255 ); } (?im)error.+?evaluable.+?constant.+?value.+?expected.+?instead.+?of.+?operation (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - hand-made function in range (integer ) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct() return integer{ return 5; } type integer myIntType ( 255 .. myFunct() ); } (?im)error.+?Reference.+?constant.+?expected.+?instead (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - both types of functions in range (float ) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct() return float{ return 5.0; } type float myIntType ( rnd() .. myFunct() ); } (?im)error.+?evaluable.+?constant.+?value.+?expected.+?instead.+?of.+?operation (?im)error.+?Reference.+?constant.+?expected.+?instead (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - rnd() in list (integer ) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myIntType ( float2int(rnd()), 255 ); } (?im)error.+?evaluable.+?constant.+?value.+?expected.+?instead.+?of.+?operation (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - hand-made function in list (integer ) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct() return integer{ return 5; } type integer myIntType ( 255, myFunct() ); } (?im)error.+?Reference.+?constant.+?expected.+?instead (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Values are not constants or literals in subtype-specifications - both types of functions in list (float ) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct() return float{ return 5.0; } type float myIntType ( rnd(), 255.0, myFunct() ); } (?im)error.+?evaluable.+?constant.+?value.+?expected.+?instead.+?of.+?operation (?im)error.+?Reference.+?constant.+?expected.+?instead (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.Negative string lengths .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/13. Strategy: TTCN-3 permits specification of length restrictions on string types. In all cases, the boundaries shall evaluate to non-negative integer or derived integer constant values. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.type and ranged type definition in definition part for charstring :li D='-'.charstring in definition part :li D='-'.bitstring in function :elist. .*---------------------------------------------------------------------* :h4.Negative string lengths - type definition (charstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer i:= -6; type charstring myChars length( i); } (?im)error.+?length.+?restriction.+?must.+?non-negative (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative string lengths - ranged type definition (charstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer i:= -5; type charstring myChars length( i..3); } (?im)error.+?Lower.+?boundary.+?length.+?restriction.+?must.+?non-negative (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative string lengths - using (charstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring myChars:= "aiyyo"; const charstring f:= myChars[-1]; } (?im)error.+?non-negative.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative string lengths - using (bitstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer i:= -9; const bitstring myBits:= '100001'B; const bitstring f:= myBits[i]; } (?im)error.+?non-negative.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.Dimension in arrays .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/14. Strategy: Array dimensions shall be specified using constant expressions which shall evaluate to a positive integer value. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.declaration of integer array with references in control part and function :li D='-'.declaration of timer array with references in control part and function :li D='-'.declaration of integer ranged array with references in control part and function :li D='-'.declaration of timer ranged array with references in control part and function :li D='-'.declaration of integer array with negative numbers in control part and function :li D='-'.declaration of timer array with negative numbers in control part and function :li D='-'.declaration of port array with negative numbers in definition part :li D='-'.declaration of integer ranged array with negative numbers in control part and function :li D='-'.declaration of timer ranged array with negative numbers in control part and function :li D='-'.declaration of port ranged array with negative numbers in control part and function :li D='-'.declaration of integer array with zero number in control part and function :li D='-'.declaration of timer array with zero numbers in control part and function :li D='-'.declaration of port array with zero numbers in definition part :li D='-'.using of integer array with negative numbers in control part and function :li D='-'.using of timer array with negative numbers in control part and function :li D='-'.using of port array with negative numbers in function :li D='-'.using of integer ranged array with negative numbers in control part and function :li D='-'.using of timer ranged array with negative numbers in control part and function :li D='-'.using of port ranged array with negative numbers in function :elist. NOTE: it works for timer arrays .*---------------------------------------------------------------------* :h4.Dimension in arrays - variable declaration with references (integer array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var integer i:= 4; // TR693 var integer myArr[2][i]; } } (?im)error.+?Reference.+?to.+?constant.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - variable declaration with references (integer array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var integer i:= 9; // TR693 var integer myArr[i][3]; } } (?im)error.+?Reference.+?to.+?constant.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - timer declaration with references (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var integer i:= 4; timer myTimerArr[2][i]; } } (?im)error.+?Reference.+?to.+?constant.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - timer declaration with references (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var integer i:= 9; // TR 693 timer myTimerArr[i][3]; } } (?im)error.+?Reference.+?to.+?constant.+?value.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - port declaration with references (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { //TR 726 type port myport message{inout charstring}; type myport akarmi[5]; } (?im)error.+?cannot.+?embedded.+?into.+?array.+?type (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - variable declaration with references (integer ranged-array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var integer i:= 4; // TR 693 var integer myArr[2..i][3..4]; } } (?im)error.+?Reference.+?to.+?constant.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - variable declaration with references (integer ranged-array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var integer i:= 4; // TR 693 var integer myArr[2..6][3..i]; } } (?im)error.+?Reference.+?to.+?constant.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - timer declaration with references (ranged-array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var integer i:= 4; timer myTimerArr[i..6][3..4]; } } (?im)error.+?Reference.+?to.+?constant.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - timer declaration with references (ranged-array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var integer i:= 4; timer myTimerArr[2..i][3..4]; } } (?im)error.+?Reference.+?to.+?constant.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - variable declaration with negative literal (integer array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var integer myArr[2][-3]; } } (?im)error.+?positive.+?value.+?expected.+?array.+?size (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - variable declaration with negative constants (integer array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ const integer i:= -5; var integer myArr[i][3]; } } (?im)error.+?positive.+?value.+?expected.+?array.+?size (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - timer declaration with negative literal (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer myArr[2][-3]; } } (?im)error.+?positive.+?integer.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - timer declaration with negative constants (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ const integer i:= -5; timer myArr[i][3]; } } (?im)error.+?positive.+?integer.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - port declaration with negative constants (in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myPort message{inout charstring}; const integer i := -5; type component myComp{ port myPort ports[i]; } } (?im)error.+?positive.+?integer.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - variable declaration with negative literal (integer ranged-array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var integer myArr[2..6][-8..10]; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - variable declaration with negative constants (integer ranged-array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ const integer i:= -3; var integer myArr[i..6][8..10]; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - timer declaration with negative literal (ranged-array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer myArr[2..6][-8..10]; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - timer declaration with negative constants (ranged-array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ const integer i:= -3; timer myArr[i..6][8..10]; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - port declaration with negative constants (ranged-array in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myPort message{inout charstring}; const integer i := -5; type component myComp{ port myPort ports[i..10]; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - variable declaration with zero constants (integer array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var integer myArr[0]; } } (?im)error.+?positive.+?value.+?expected.+?array.+?size (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - variable declaration with zero literal (integer array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ const integer i:= 0; var integer myArr[i]; } } (?im)error.+?positive.+?value.+?expected.+?array.+?size (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - timer declaration with zero constants (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer myArr[0]; } } (?im)error.+?positive.+?integer.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - port declaration with zero constants (in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myPort message{inout charstring}; type component myComp{ port myPort ports[0]; } } (?im)error.+?positive.+?integer.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - timer declaration with zero literal (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ const integer i:= 0; timer myArr[i]; } } (?im)error.+?positive.+?integer.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - port declaration with zero literal (in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myPort message{inout charstring}; const integer i := 0; type component myComp{ port myPort ports[i]; } } (?im)error.+?positive.+?integer.+?value.+?expected (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - using (timer array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer myArr[3]; myArr[-1].start( 2.0); } } (?im)error.+?Array.+?index.+?underflow (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - using (timer array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ timer myArr[3]; const integer i:= -3; myArr[i].start( 2.0); } } (?im)error.+?Array.+?index.+?underflow (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - using (port array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myPort message{inout charstring}; type component myComp{ port myPort ports[3]; } function myFunc() runs on myComp{ const integer i := -3; ports[i].start; } } (?im)\berror\b.+?index.+?underflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - using (integer ranged-array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var integer myArr[4..6][8..10]; const integer i:= -3; // TR694 var integer f:= myArr[i][9]; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - using (integer ranged-array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ const integer i:= 3; var integer myArr[i..6][8..10]; // TR694 var integer f:= myArr[4][-9]; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - using (timer ranged-array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer myArr[3..6][1..10]; const integer i:= -3; // TR695 myArr[i][2].start(9.0); } } (?im)\berror\b.+?index.+?underflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - using (timer ranged-array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ timer myArr[3..6][1..10]; const integer i:= -3; // TR695 myArr[i][2].start(9.0); } } (?im)\berror\b.+?index.+?underflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Dimension in arrays - using (port ranged-array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myPort message{inout charstring}; type component myComp{ port myPort ports[3..5]; } function myFunc() runs on myComp{ const integer i := -3; ports[i].start; } } (?im)\berror\b.+?index.+?underflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.Upper and lower boundaries .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/15. Strategy: The lower boundary shall be smaller than the upper boundary in array definitions, string length restrictions and in definitions using ranges. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.charstring and integer value-ranges in definition part :li D='-'.mixed integer list and value-ranges in definition part :li D='-'.charstring and bitstring length restriction in definition part :li D='-'.integer array declaration in control part :li D='-'.timer array declaration in definition part :li D='-'.port array declaration in definition part :li D='-'.charstring array declaration in function :elist. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - value-range (charstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type charstring f ( "z".."a"); } (?im)error.+?lower.+?boundary.+?bigger.+?than.+?upper (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - value-range (integer in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer i:= 500; type integer f (i..255); } (?im)error.+?lower.+?boundary.+?bigger.+?than.+?upper (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - mixed value-list and value-range (integer in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer f ( 1, 2, 300..255, 500); } (?im)error.+?lower.+?boundary.+?bigger.+?than.+?upper (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - length restriction (charstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer i:= 5; type charstring f length(7..i); } (?im)error.+?upper.+?boundary.+?length.+?restriction.+?cannot.+?be.+?smaller.+?than.+?lower (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - length restriction (bitstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type bitstring f length(6..3); } (?im)error.+?upper.+?boundary.+?length.+?restriction.+?cannot.+?be.+?smaller.+?than.+?lower (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - array definition (integer in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ const integer i:= 7; var integer f [1..2][i..4][3..4]; } } (?im)error.+?lower.+?bound.+?array.+?greater.+?upper.+?bound (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - array definition (charstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var charstring f [9..2][1..5]; } } (?im)error.+?lower.+?bound.+?array.+?greater.+?upper.+?bound (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - timer-array definition (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ const integer i:= 7; timer f [1..2][i..4][3..4]; } } (?im)error.+?lower.+?bound.+?array.+?index.+?greater.+?than.+?upper (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - timer-array definition (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ timer f [9..2][1..5]; } } (?im)error.+?lower.+?bound.+?array.+?index.+?greater.+?than.+?upper (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - port-array definition (in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myport message{ inout charstring } type component mycomp{ port myport ports[6..5] } } (?im)error.+?lower.+?bound.+?array.+?index.+?greater.+?than.+?upper (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Upper and lower boundaries - port-array definition (in def. part) 2 .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myport message{ inout charstring } const integer i := 6; type component mycomp{ port myport ports[i..5] } } (?im)error.+?lower.+?bound.+?array.+?index.+?greater.+?than.+?upper (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: .*---------------------------------------------------------------------* :h3.Overindexing .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/16. Strategy: When referencing an element of an array, the index shall evaluate to a valid position within string and array. All occurances shall be tested, where such a notation can be used. Tested: :nl.Overindexing :list. :li D='-'.bitstring in definition part :li D='-'.charstring in control part :li D='-'.hexstring in function :li D='-'.integer array in control part :li D='-'.timer array in control part and function :li D='-'.port array in definition part :li D='-'.charstring array in function :li D='-'.integer ranged array in control part :li D='-'.timer ranged array in control part and function :li D='-'.port ranged array in definition part :li D='-'.float arnged array in function :elist. :nl.Underindexing :list. :li D='-'.integer ranged array in control part :li D='-'.timer array in control part and function :li D='-'.timer ranged array in control part and function :li D='-'.port array in definition part :li D='-'.port ranged array in definition part :li D='-'.float ranged array in function :elist. .*---------------------------------------------------------------------* :h4.Overindexing - string overindexing (bitstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type bitstring myBits length(3..5); const myBits r:= '11111'B; const bitstring f:= r[5]; } (?im)error.+?Index.+?overflow.+?accessing.+?string.+?element (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - string overindexing (charstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type charstring myChars length(3..13); const myChars r:= "Ford Fairlane"; control{ const charstring f:= r[15]; } } (?im)error.+?Index.+?overflow.+?accessing.+?string.+?element (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - string overindexing (hexstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type hexstring myHexes length(1..10); const myHexes r:= 'AbbaBaba'H; function myFunct(){ const hexstring f:= r[9]; } } (?im)error.+?Index.+?overflow.+?accessing.+?string.+?element (?im)\bNotify\b.+?\bcode\b.+?\bnot\b.+?\bgenerated\b (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - array overindexing (integer in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer i:= 10; control{ var integer myArr[2][4]; myArr[1]:= { 1, 2, 3, 4 }; // TR694 var integer f:= myArr[1][i]; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - array overindexing (charstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var charstring myArr[2][4]; myArr[1]:= { "EEE", "MUHAHA", "AIYYO", "GERAPPA"}; // TR694 myArr[2][6]:= "ERIXON"; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - timer-array overindexing (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer myArr[2][4]:= {{ 1.0, 2.0, 3.0, 4.0 }, { 1.0, 2.0, 3.0, 4.0 }}; timer f; const integer i:= 5; // TR695 f.start( myArr[1][i].read); } } (?im)\berror\b.+?index.+?overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - timer-array overindexing (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ timer myArr[2][4]:= {{ 1.0, 2.0, 3.0, 4.0 }, { 1.0, 2.0, 3.0, 4.0 }}; timer f; const integer i:= 5; // TR695 f.start( myArr[1][i].read); } } (?im)\berror\b.+?index.+?overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - port-array overindexing (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myport message{ inout charstring } type component mycomp{ port myport ports[5] } function myFunc() runs on mycomp{ ports[5].start; } } (?im)\berror\b.+?index.+?overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged-array overindexing (integer in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var integer myArr[2..4][5..8]; // TR694 var integer f:= myArr[6][9]; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged-array overindexing (float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer i:= 6; const integer j:= 10; function myFunct(){ var float myArr[2..4][5..8]; // TR694 myArr[i][j]:= 3.14; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged timer-array overindexing (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer myArr[2..3][4..7]:= {{ 1.0, 2.0, 3.0, 4.0 }, { 1.0, 2.0, 3.0, 4.0 }}; timer f; const integer i:= 9; // TR695 f.start( myArr[2][i].read); } } (?im)\berror\b.+?index.+?overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged timer-array overindexing (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ timer myArr[2..3][4..7]:= {{ 1.0, 2.0, 3.0, 4.0 }, { 1.0, 2.0, 3.0, 4.0 }}; timer f; const integer i:= 9; // TR695 f.start( myArr[2][i].read); } } (?im)\berror\b.+?index.+?overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged port-array overindexing (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myport message{ inout charstring } type component mycomp{ port myport ports[5..6] } function myFunc() runs on mycomp{ ports[7].start; } } (?im)\berror\b.+?index.+?overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged-array underindexing (integer in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var integer myArr[2..4][5..8]; // TR694 var integer f:= myArr[1][3]; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged-array underindexing (integer in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[5..6]; function myFunc(){ var myint f := {1,2}; f[4] := 1; } } (?im)\berror\b.+?index.+?underflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged-array underindexing (float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer i:= 0; const integer j:= 4; function myFunct(){ var float myArr[2..4][5..8]; // TR694 myArr[i][j]:= 3.14; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged timer-array underindexing (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer myArr[2..3][4..7]:= {{ 1.0, 2.0, 3.0, 4.0 }, { 1.0, 2.0, 3.0, 4.0 }}; timer f; const integer i:= 1; // TR695 f.start( myArr[i][6].read); } } (?im)\berror\b.+?index.+?underflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged timer-array underindexing (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ timer myArr[2..3][4..7]:= {{ 1.0, 2.0, 3.0, 4.0 }, { 1.0, 2.0, 3.0, 4.0 }}; timer f; const integer i:= 2; // TR695 f.start( myArr[2][i].read); } } (?im)\berror\b.+?index.+?underflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Overindexing - ranged port-array underindexing (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port myport message{ inout charstring } type component mycomp{ port myport ports[5..6] } function myFunc() runs on mycomp{ ports[4].start; } } (?im)\berror\b.+?index.+?underflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.Negative timer duration .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/17. Strategy: A timer declaration may have an optional default duration value assigned to it. The timer shall be started with this value if no other value is specified. This value shall be positive, but we can use constants too. Same is true for timer arrays and the oprional timer of the execute operation. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.timer default values in control part and function :li D='-'.timer starting values in control part and function :li D='-'.timer-array default values in control part and function :li D='-'.timer-array starting values in control part and function :li D='-'.execution timer :elist. .*---------------------------------------------------------------------* :h4.Negative timer duration - default (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer T:= -12.0; } } (?im)error.+?non-negative.+?float.+?value.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative timer duration - default (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float f:= -2.22; function myFunct(){ timer T:= f; } } (?im)error.+?non-negative.+?float.+?value.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative timer duration - array default (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer T[5]:= { 1.0, 8.9, -3.14, 1.1, 1.5 }; } } (?im)error.+?non-negative.+?float.+?value.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative timer duration - array default (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float f:= -2.22; function myFunct(){ timer T[5]:= { 1.0, f, 3.14, -, 1.5 }; } } (?im)error.+?non-negative.+?float.+?value.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative timer duration - starting value (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer T:= 12.0; T.start( -5.9 ); } } (?im)error.+?timer.+?duration.+?negative (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative timer duration - starting value (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float f:= -66.3; function myFunct(){ timer T:= 1234.56; T.start( f ); } } (?im)error.+?timer.+?duration.+?negative (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative timer duration - array starting value (in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer T[5]:= { 1.0, 8.9, 3.14, 1.1, 1.5 }; T[1].start( - 125.0 ); } } (?im)error.+?timer.+?duration.+?negative (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative timer duration - array starting value (in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float f:= -18.07; function myFunct(){ timer T[5]:= { 3.3, 3.4, 3.14, 4.1, 2.3 }; T[1].start( f ); } } (?im)error.+?timer.+?duration.+?negative (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Negative timer duration - execution timer .*---------------------------------------------------------------------* :xmp tab=0. module x { type component myComponent{ const integer i:= 1; } function myFunct(){ timer T1:= 20.0; T1.start; } testcase myTestCase() runs on myComponent{ myFunct(); } control{ execute( myTestCase(), -5.3 ); } } (?im)error.+?testcase.+?guard.+?timer.+?negative.+?duration (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.Default module parameters .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/18. Strategy: Default values of module parameters shall be constant expression only. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.module parameters with inner function :li D='-'.module parameters with hand-made function :elist. .*---------------------------------------------------------------------* :h4.Default module parameters - inner function .*---------------------------------------------------------------------* :xmp tab=0. module x { modulepar { integer i:= float2int( rnd()); charstring ch:= "aiyyo" }; } (?im)error.+?evaluable.+?constant.+?value.+?expected.+?instead.+?of.+?operation (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Default module parameters - hand-made function .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct() return charstring{ return "RETURNED"; } modulepar { integer i:= 3; charstring ch:= "aiyyo" & myFunct() }; } (?im)error.+?Reference.+?constant.+?value.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h2.Variable references .*---------------------------------------------------------------------* Rule: each variable reference shall conform to the context-specific rules .*---------------------------------------------------------------------* :h3.No value shall be assigned to constant elements .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/19. Strategy: can't change the value of constants, external constants and module parameters. All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.constants, external constants and module parameters in control part and function with ":=" :li D='-'.constants, external constants and module parameters in function with "-> value" :elist. .*---------------------------------------------------------------------* :h4.No value shall be assigned to constant elements - const in control part (:=) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer c:= 1; control{ c:=2; } } (?im)error.+?Reference.+?variable.+?template.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.No value shall be assigned to constant elements - const in function (:=) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer c:= 1; function myFunct(){ c:=2; } } (?im)error.+?Reference.+?variable.+?template.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.No value shall be assigned to constant elements - const in function ( -> value) .*---------------------------------------------------------------------* :xmp tab=0. value)> module x { const integer c:= 2; type port portT message { in integer } with {extension "internal"} type component comp { port portT myPort; } function myFunct() runs on comp { myPort.receive( ?) -> value c; } } (?im)error.+?Reference.+?variable.+?value.+?parameter.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.No value shall be assigned to constant elements - external const in control part (:=) .*---------------------------------------------------------------------* :xmp tab=0. module x { external const integer c; control{ c:=2; } } (?im)error.+?Reference.+?variable.+?template.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.No value shall be assigned to constant elements - external const in function (:=) .*---------------------------------------------------------------------* :xmp tab=0. module x { external const integer c; function myFunct(){ c:=2; } } (?im)error.+?Reference.+?variable.+?template.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.No value shall be assigned to constant elements - external const in function ( -> value) .*---------------------------------------------------------------------* :xmp tab=0. value)> module x { external const integer c; type port portT message { in integer } with {extension "internal"} type component comp { port portT myPort; } function myFunct() runs on comp { myPort.receive( ?) -> value c; } } (?im)error.+?Reference.+?variable.+?value.+?parameter.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.No value shall be assigned to constant elements - module parameter in control part (:=) .*---------------------------------------------------------------------* :xmp tab=0. module x { modulepar{ integer c } control{ c:= 3; } } (?im)error.+?Reference.+?variable.+?template.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.No value shall be assigned to constant elements - module parameter in function (:=) .*---------------------------------------------------------------------* :xmp tab=0. module x { modulepar{ integer c } function myFunct(){ c:= 3; } } (?im)error.+?Reference.+?variable.+?template.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.No value shall be assigned to constant elements - module parameter in function (-> value) .*---------------------------------------------------------------------* :xmp tab=0. value)> module x { modulepar{ integer c } type port portT message { in integer } with {extension "internal"} type component comp { port portT myPort; } function myFunct() runs on comp { myPort.receive( ?) -> value c; } } (?im)error.+?Reference.+?variable.+?value.+?parameter.+?expected (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h2.Allowed matching mechanisms .*---------------------------------------------------------------------* .*---------------------------------------------------------------------* :h3.Allowed matching mechanisms .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/20. Strategy: SA shall detect if a template of a type uses not allowed matching mechanism.(Table 6, side 68) Either can be used the following operations: create (99), mtc (101), system (101), self (101), running (102), getverdict (123) All occurances shall be tested, where such a notation can be used. Tested: range, superset, subset, length-restriction, ifpresent mechanisms in definition part, control part and function for templates and range, superset, subset, length-restriction, ifpresent mechanisms in function for inline-templates except - "inside values" columns are not tested .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (boolean in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template boolean r:= (false .. true); } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (boolean in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template boolean r:= (false .. true); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template boolean r:= (false .. true); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (bitstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template bitstring r:= ('000'B .. '111'B); } (?im)error.+?Value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (bitstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template bitstring r:= ('000'B .. '111'B); } } (?im)error.+?Value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (bitstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template bitstring r:= ('000'B .. '111'B); } } (?im)error.+?Value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (octetstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template octetstring r:= ('0011'O .. '1111'O); } (?im)error.+?Value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (octetstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template octetstring r:= ('0011'O .. '1111'O); } } (?im)error.+?Value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (octetstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template octetstring r:= ('0011'O .. '1111'O); } } (?im)error.+?Value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (hexstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template hexstring r:= ('0011'H .. '1111'H); } (?im)error.+?Value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (hexstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template hexstring r:= ('0011'H .. '1111'H); } } (?im)error.+?Value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (hexstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template hexstring r:= ('0011'H .. '1111'H); } } (?im)error.+?Value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (record in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2 } const recT c1:= { f1:= 1, f2:= 2.0}; const recT c2:= { f1:= 5, f2:= 7.0}; template recT r:= (c1 .. c2); } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (record in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2 } const recT c1:= { f1:= 1, f2:= 2.0}; const recT c2:= { f1:= 5, f2:= 7.0}; control{ var template recT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (record in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2 } const recT c1:= { f1:= 1, f2:= 2.0}; const recT c2:= { f1:= 5, f2:= 7.0}; function myFunct(){ var template recT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (record of in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; template rofT r:= (c1 .. c2); } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (record of in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; control{ var template rofT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (record of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; function myFunct(){ var template rofT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (set in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2 } const setT c1:= { f1:= 1, f2:= 2.0}; const setT c2:= { f1:= 5, f2:= 7.0}; template setT r:= (c1 .. c2); } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (set in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2 } const setT c1:= { f1:= 1, f2:= 2.0}; const setT c2:= { f1:= 5, f2:= 7.0}; control{ var template setT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (set in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2 } const setT c1:= { f1:= 1, f2:= 2.0}; const setT c2:= { f1:= 5, f2:= 7.0}; function myFunct(){ var template setT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (set of in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set of integer sofT; const sofT c1:= { 1, 2, 3 }; const sofT c2:= { 4, 5, 6 }; template sofT r:= (c1 .. c2); } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (set of in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set of integer sofT; const sofT c1:= { 1, 2, 3 }; const sofT c2:= { 4, 5, 6 }; control{ var template sofT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (set of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set of integer sofT; const sofT c1:= { 1, 2, 3 }; const sofT c2:= { 4, 5, 6 }; function myFunct(){ var template sofT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (enumerated in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT{ ONE(1), TWO(2), THREE(3)}; const enumT c1:= ONE; const enumT c2:= THREE; template enumT r:= (c1 .. c2); } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (enumerated in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT{ ONE(1), TWO(2), THREE(3)}; const enumT c1:= ONE; const enumT c2:= THREE; control{ var template enumT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT{ ONE(1), TWO(2), THREE(3)}; const enumT c1:= ONE; const enumT c2:= THREE; function myFunct(){ var template enumT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (union in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f1:= 1 }; const uniT c2:= { f1:= 5 }; template uniT r:= (c1 .. c2); } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (union in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f1:= 1 }; const uniT c2:= { f1:= 5 }; control{ var template uniT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f1:= 1 }; const uniT c2:= { f1:= 5 }; function myFunct(){ var template uniT r:= (c1 .. c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (array in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[1]; const myint c1:={1}; const myint c2 :={3}; template myint r :=(c1..c2); } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[1]; const myint c1:={1}; const myint c2 :={3}; control{ template myint r :=(c1..c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template range (array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[1]; const myint c1:={1}; const myint c2 :={3}; function myFunct(){ template myint r :=(c1..c2); } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (boolean in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const boolean c1:= false; const boolean c2:= true; template boolean r:= superset (c1, c2); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (boolean in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const boolean c1:= false; const boolean c2:= true; control{ var template boolean r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const boolean c1:= false; const boolean c2:= true; function myFunct(){ var template boolean r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (integer in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer c1:= 1; const integer c2:= 2; const integer c3:= 3; template integer r:= superset (c1, c2, c3); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (integer in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer c1:= 1; const integer c2:= 2; const integer c3:= 3; control{ var template integer r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (integer in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer c1:= 1; const integer c2:= 2; const integer c3:= 3; function myFunct(){ var template integer r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (float in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float c1:= 1.6; const float c2:= 2.4; const float c3:= 3.9; template float r:= superset (c1, c2, c3); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (float in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float c1:= 1.1; const float c2:= 2.3; const float c3:= 3.1; control{ var template float r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float c1:= 1.1; const float c2:= 2.9; const float c3:= 3.2; function myFunct(){ var template float r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (bitstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const bitstring c1:= '101'B; const bitstring c2:= '110'B; const bitstring c3:= '111'B; template bitstring r:= superset (c1, c2, c3); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (bitstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const bitstring c1:= '101'B; const bitstring c2:= '110'B; const bitstring c3:= '111'B; control{ var template bitstring r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (bitstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const bitstring c1:= '101'B; const bitstring c2:= '110'B; const bitstring c3:= '111'B; function myFunct(){ var template bitstring r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (octetstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const octetstring c1:= '1011'O; const octetstring c2:= '1110'O; const octetstring c3:= '1111'O; template octetstring r:= superset (c1, c2, c3); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (octetstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const octetstring c1:= '1011'O; const octetstring c2:= '1110'O; const octetstring c3:= '1111'O; control{ var template octetstring r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (octetstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const octetstring c1:= '1011'O; const octetstring c2:= '1110'O; const octetstring c3:= '1111'O; function myFunct(){ var template octetstring r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (hexstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const hexstring c1:= '1011'H; const hexstring c2:= '1110'H; const hexstring c3:= '1111'H; template hexstring r:= superset (c1, c2, c3); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (hexstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const hexstring c1:= '1011'H; const hexstring c2:= '1110'H; const hexstring c3:= '1111'H; control{ var template hexstring r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (hexstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const hexstring c1:= '1011'H; const hexstring c2:= '1110'H; const hexstring c3:= '1111'H; function myFunct(){ var template hexstring r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (charstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring c1:= "ogin"; const charstring c2:= "dwa"; const charstring c3:= "try"; template charstring r:= superset (c1, c2, c3); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (charstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring c1:= "ogin"; const charstring c2:= "dwa"; const charstring c3:= "try"; control{ var template charstring r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (charstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring c1:= "ogin"; const charstring c2:= "dwa"; const charstring c3:= "try"; function myFunct(){ var template charstring r:= superset (c1, c2, c3); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (record in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } const recT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const recT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; template recT r:= superset (c1, c2); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (record in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } const recT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const recT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; control{ var template recT r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (record in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } const recT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const recT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; function myFunct(){ var template recT r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (record of in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; template rofT r:= superset (c1, c2); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (record of in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; control{ var template rofT r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (record of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; function myFunct(){ var template rofT r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (set in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } const setT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const setT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; template setT r:= superset (c1, c2); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (set in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } const setT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const setT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; control{ var template setT r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (set in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } const setT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const setT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; function myFunct(){ var template setT r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (enumerated in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; const enumT c1:= ONE; const enumT c2:= TWO; template enumT r:= superset (c1, c2); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (enumerated in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; const enumT c1:= ONE; const enumT c2:= TWO; control{ var template enumT r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; const enumT c1:= ONE; const enumT c2:= TWO; function myFunct(){ var template enumT r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (union in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f1:= 1 }; const uniT c2:= { f2:= 7.0 }; template uniT r:= superset (c1, c2); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (union in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f1:= 1 }; const uniT c2:= { f2:= 7.0 }; control{ var template uniT r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f1:= 1 }; const uniT c2:= { f2:= 7.0 }; function myFunct(){ var template uniT r:= superset (c1, c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (array in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[1]; const myint c1:={1}; const myint c2 :={3}; template myint r := superset(c1,c2); } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[1]; const myint c1:={1}; const myint c2 :={3}; control{ template myint r := superset(c1,c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template superset (array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[1]; const myint c1:={1}; const myint c2 :={3}; function myFunct(){ template myint r := superset(c1,c2); } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (boolean in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const boolean c1:= false; const boolean c2:= true; template boolean r:= subset (c1, c2); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (boolean in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const boolean c1:= false; const boolean c2:= true; control{ var template boolean r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const boolean c1:= false; const boolean c2:= true; function myFunct(){ var template boolean r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (integer in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer c1:= 1; const integer c2:= 2; const integer c3:= 3; template integer r:= subset (c1, c2, c3); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (integer in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer c1:= 1; const integer c2:= 2; const integer c3:= 3; control{ var template integer r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (integer in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer c1:= 1; const integer c2:= 2; const integer c3:= 3; function myFunct(){ var template integer r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (float in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float c1:= 1.6; const float c2:= 2.4; const float c3:= 3.9; template float r:= subset (c1, c2, c3); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (float in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float c1:= 1.1; const float c2:= 2.3; const float c3:= 3.1; control{ var template float r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float c1:= 1.1; const float c2:= 2.9; const float c3:= 3.2; function myFunct(){ var template float r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (bitstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const bitstring c1:= '101'B; const bitstring c2:= '110'B; const bitstring c3:= '111'B; template bitstring r:= subset (c1, c2, c3); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (bitstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const bitstring c1:= '101'B; const bitstring c2:= '110'B; const bitstring c3:= '111'B; control{ var template bitstring r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (bitstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const bitstring c1:= '101'B; const bitstring c2:= '110'B; const bitstring c3:= '111'B; function myFunct(){ var template bitstring r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (octetstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const octetstring c1:= '1011'O; const octetstring c2:= '1110'O; const octetstring c3:= '1111'O; template octetstring r:= subset (c1, c2, c3); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (octetstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const octetstring c1:= '1011'O; const octetstring c2:= '1110'O; const octetstring c3:= '1111'O; control{ var template octetstring r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (octetstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const octetstring c1:= '1011'O; const octetstring c2:= '1110'O; const octetstring c3:= '1111'O; function myFunct(){ var template octetstring r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (hexstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const hexstring c1:= '1011'H; const hexstring c2:= '1110'H; const hexstring c3:= '1111'H; template hexstring r:= subset (c1, c2, c3); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (hexstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const hexstring c1:= '1011'H; const hexstring c2:= '1110'H; const hexstring c3:= '1111'H; control{ var template hexstring r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (hexstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const hexstring c1:= '1011'H; const hexstring c2:= '1110'H; const hexstring c3:= '1111'H; function myFunct(){ var template hexstring r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (charstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring c1:= "ogin"; const charstring c2:= "dwa"; const charstring c3:= "try"; template charstring r:= subset (c1, c2, c3); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (charstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring c1:= "ogin"; const charstring c2:= "dwa"; const charstring c3:= "try"; control{ var template charstring r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (charstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring c1:= "ogin"; const charstring c2:= "dwa"; const charstring c3:= "try"; function myFunct(){ var template charstring r:= subset (c1, c2, c3); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (record in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } const recT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const recT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; template recT r:= subset (c1, c2); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (record in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } const recT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const recT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; control{ var template recT r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (record in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } const recT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const recT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; function myFunct(){ var template recT r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (record of in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; template rofT r:= subset (c1, c2); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (record of in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; control{ var template rofT r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (record of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; function myFunct(){ var template rofT r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (set in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } const setT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const setT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; template setT r:= subset (c1, c2); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (set in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } const setT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const setT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; control{ var template setT r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (set in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } const setT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const setT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; function myFunct(){ var template setT r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (enumerated in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; const enumT c1:= ONE; const enumT c2:= TWO; template enumT r:= subset (c1, c2); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (enumerated in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; const enumT c1:= ONE; const enumT c2:= TWO; control{ var template enumT r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; const enumT c1:= ONE; const enumT c2:= TWO; function myFunct(){ var template enumT r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (union in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f1:= 1 }; const uniT c2:= { f2:= 7.0 }; template uniT r:= subset (c1, c2); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (union in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f1:= 1 }; const uniT c2:= { f2:= 7.0 }; control{ var template uniT r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f1:= 1 }; const uniT c2:= { f2:= 7.0 }; function myFunct(){ var template uniT r:= subset (c1, c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (array in def. part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[1]; const myint c1:={1}; const myint c2 :={3}; template myint r := subset(c1,c2); } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[1]; const myint c1:={1}; const myint c2 :={3}; control{ template myint r := subset(c1,c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template subset (array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[1]; const myint c1:={1}; const myint c2 :={3}; function myFunct(){ template myint r := subset(c1,c2); } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (boolean in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template boolean r:= ? length(1); } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (boolean in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template boolean r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template boolean r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (integer in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template integer r:= ? length(1); } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (integer in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template integer r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (integer in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template integer r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (float in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template float r:= ? length(1); } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (float in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template float r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template float r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (record in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } template recT r:= ? length(1); } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (record in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } control{ var template recT r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (record in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } function myFunct(){ var template recT r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (set in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } template setT r:= ? length(1); } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (set in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } control{ var template setT r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (set in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } function myFunct(){ var template setT r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (enumerated in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; template enumT r:= ? length(1); } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (enumerated in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; control{ var template enumT r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; function myFunct(){ var template enumT r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (union in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } template uniT r:= ? length(1); } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (union in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } control{ var template uniT r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } function myFunct(){ var template uniT r:= ? length(1); } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (array in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; //TR 727 template arrint r:= ? length(10); } (?im)error.+?number.+?elements.+?allowed.+?length.+?restriction.+?contradicts.+?array.+?size (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; control{ //TR 727 template arrint r:= ? length(10); } } (?im)error.+?number.+?elements.+?allowed.+?length.+?restriction.+?contradicts.+?array.+?size (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template length-restriction (array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; function myFunct(){ //TR 727 template arrint r:= ? length(10); } } (?im)error.+?number.+?elements.+?allowed.+?length.+?restriction.+?contradicts.+?array.+?size (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (boolean in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template boolean f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (boolean in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template boolean f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template boolean f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (integer in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template integer f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (integer in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template integer f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (integer in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template integer f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (float in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template float f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (float in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template float f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template float f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (bitstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template bitstring f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (bitstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template bitstring f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (bitstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template bitstring f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (octetstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template octetstring f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (octetstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template octetstring f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (octetstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template octetstring f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (hexstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template hexstring f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (hexstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template hexstring f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (hexstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template hexstring f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (charstring in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { template charstring f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (charstring in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var template charstring f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (charstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var template charstring f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (record of in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; template rofT f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (record of in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; control{ var template rofT f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (record of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; function myFunct(){ var template rofT f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (set of in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set of integer sofT; template sofT f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (set of in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set of integer sofT; control{ var template sofT f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (set of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set of integer sofT; function myFunct(){ var template sofT f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (enumerated in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; template enumT f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (enumerated in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; control{ var template enumT f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; function myFunct(){ var template enumT f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (union in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } template uniT f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (union in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } control{ var template uniT f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } function myFunct(){ var template uniT f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (array in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; template arrint f:= ? ifpresent; } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (array in control part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; control{ template arrint f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - template ifpresent (array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; function myFunct(){ template arrint f:= ? ifpresent; } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in boolean } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { const boolean c1:= false; const boolean c2:= true; alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (bitstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in bitstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { const bitstring c1:= '000'B; const bitstring c2:= '111'B; alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (octetstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in octetstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { const octetstring c1:= '0000'O; const octetstring c2:= '1111'O; alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (hexstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in hexstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { const hexstring c1:= '0000'H; const hexstring c2:= '1111'H; alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (record in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } type port portT message { in recT } with {extension "internal"} type component c { port portT myPort; } const recT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const recT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; function myFunct() runs on c { alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (record of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; type port portT message { in rofT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (set in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } type port portT message { in setT } with {extension "internal"} type component c { port portT myPort; } const setT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const setT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; function myFunct() runs on c { alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (set of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set of integer sofT; const sofT c1:= { 1, 2, 3 }; const sofT c2:= { 4, 5, 6 }; type port portT message { in sofT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; const enumT c1:= ONE; const enumT c2:= TWO; type port portT message { in enumT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f1:= 1 }; const uniT c2:= { f1:= 5 }; type port portT message { in uniT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template range (array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; const arrint c1:= { 1 }; const arrint c2:= { 5 }; type port portT message { in arrint } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { //TR 728 alt{ [] myPort.receive( (c1..c2) ) {} } } } (?im)error.+?value.+?range.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const boolean c1:= false; const boolean c2:= true; type port portT message { in boolean } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (integer in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer c1:= 1; const integer c2:= 5; type port portT message { in integer } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float c1:= 1.0; const float c2:= 5.0; type port portT message { in float } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (bitstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const bitstring c1:= '0000'B; const bitstring c2:= '1111'B; type port portT message { in bitstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (octetstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const octetstring c1:= '0000'O; const octetstring c2:= '1111'O; type port portT message { in octetstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (hexstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const hexstring c1:= '0000'H; const hexstring c2:= '1111'H; type port portT message { in hexstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (charstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring c1:= "a"; const charstring c2:= "z"; type port portT message { in charstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (record in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } const recT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const recT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; type port portT message { in recT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (record of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; type port portT message { in rofT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (set in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } const setT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const setT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; type port portT message { in setT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; const enumT c1:= ONE; const enumT c2:= TWO; type port portT message { in enumT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f3:= "a"}; const uniT c2:= { f3:= "z"}; type port portT message { in uniT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template superset (array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; const arrint c1:= { 1 }; const arrint c2:= { 5 }; type port portT message { in arrint } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( superset(c1,c2) ) {} } } } (?im)error.+?superset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const boolean c1:= false; const boolean c2:= true; type port portT message { in boolean } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (integer in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const integer c1:= 1; const integer c2:= 5; type port portT message { in integer } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const float c1:= 1.0; const float c2:= 5.0; type port portT message { in float } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (bitstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const bitstring c1:= '0000'B; const bitstring c2:= '1111'B; type port portT message { in bitstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (octetstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const octetstring c1:= '0000'O; const octetstring c2:= '1111'O; type port portT message { in octetstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (hexstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const hexstring c1:= '0000'H; const hexstring c2:= '1111'H; type port portT message { in hexstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (charstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { const charstring c1:= "a"; const charstring c2:= "z"; type port portT message { in charstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (record in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } const recT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const recT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; type port portT message { in recT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (record of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer rofT; const rofT c1:= { 1, 2, 3 }; const rofT c2:= { 4, 5, 6 }; type port portT message { in rofT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (set in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } const setT c1:= { f1:= 1, f2:= 2.0, f3:= "a"}; const setT c2:= { f1:= 5, f2:= 7.0, f3:= "z"}; type port portT message { in setT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; const enumT c1:= ONE; const enumT c2:= TWO; type port portT message { in enumT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } const uniT c1:= { f3:= "a"}; const uniT c2:= { f3:= "z"}; type port portT message { in uniT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template subset (array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; const arrint c1:= { 1 }; const arrint c2:= { 5 }; type port portT message { in arrint } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( subset(c1,c2) ) {} } } } (?im)error.+?subset.+?match.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template length-restriction (boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in boolean } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? length(1) ) {} } } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template length-restriction (integer in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in integer } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? length(1) ) {} } } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template length-restriction (float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in float } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? length(1) ) {} } } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template length-restriction (record in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT{ integer f1, float f2, charstring f3 } type port portT message { in recT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? length(1) ) {} } } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template length-restriction (set in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set setT{ integer f1, float f2, charstring f3 } type port portT message { in setT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? length(1) ) {} } } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template length-restriction (enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; type port portT message { in enumT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? length(1) ) {} } } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template length-restriction (union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } type port portT message { in uniT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? length(1) ) {} } } } (?im)error.+?Length.+?restriction.+?cannot.+?used (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template length-restriction (array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; const arrint c1:= { 1 }; const arrint c2:= { 5 }; type port portT message { in arrint } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? length(10) ) {} } } } (?im)error.+?number.+?elements.+?allowed.+?length.+?restriction.+?contradicts.+?array.+?size (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (boolean in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in boolean } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (integer in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in integer } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (float in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in float } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (bitstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in bitstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (octetstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in octetstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (hexstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in hexstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (charstring in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type port portT message { in charstring } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (record of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer myT; type port portT message { in myT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (set of in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type set of integer myT; type port portT message { in myT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (enumerated in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), THREE(3) }; type port portT message { in enumT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (union in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type union uniT{ integer f1, float f2, charstring f3 } type port portT message { in uniT } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent ) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Allowed matching mechanisms - inline-template ifpresent (array in function) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer arrint[1]; const arrint c1:= { 1 }; const arrint c2:= { 5 }; type port portT message { in arrint } with {extension "internal"} type component c { port portT myPort; } function myFunct() runs on c { alt{ [] myPort.receive( ? ifpresent) {} } } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h2.Infinite recursive loops .*---------------------------------------------------------------------* NOTE: In case of non-constant ele For example: template mytype t := { f := t } s but var mytype v := { f := v } is not .*---------------------------------------------------------------------* :h3.Infinite recursive loops in templates/values .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/21. Strategy: SA shall detect the infinite recursive loops in templates/values. Two types of infinite loops are existing: x:= x.field; and x:= { f1:= x... }; All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.1, 2 and 3 steps long circles in definition part :li D='-'.2, 3 and 4 steps long cross circles in definition part :li D='-'.3 steps long double cross circles in definition part :elist. .*---------------------------------------------------------------------* :h4.Infinite recursive loops in templates/values - one step long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer f1, float f2, charstring f3, integer f4 } template recT temp1:= { f1:= temp1.f1, f2:= 1.1, f3:= "ERIXON", f4:= 1 }; } (?im)error.+?Circular.+?reference (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Infinite recursive loops in templates/values - one steps long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type integer myint[2]; template myint t := {0,t[1]}; } (?im)error.+?Circular.+?reference (?is)\berror: (?im)error.+?Circular.+?reference :exmp. .*---------------------------------------------------------------------* :h4.Infinite recursive loops in templates/values - two steps long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer f1, float f2, charstring f3, integer f4 } // TR 696 template recT temp1:= { f1:= temp1.f4, f2:= 1.1, f3:= "ERIXON", f4:= temp1.f1 }; } (?im)error.+?Circular.+?reference (?is)\berror: (?im)error.+?Circular.+?reference :exmp. .*---------------------------------------------------------------------* :h4.Infinite recursive loops in templates/values - three steps long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer f1, float f2, charstring f3, integer f4, integer f5 } // TR 696 template recT temp1:= { f1:= temp1.f4, f2:= 1.1, f3:= "ERIXON", f4:= temp1.f5, f5:= temp1.f1 }; } (?im)error.+?Circular.+?reference (?is)\berror: (?im)error.+?Circular.+?reference :exmp. .*---------------------------------------------------------------------* :h4.Infinite recursive loops in templates/values - cross two steps long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer f1, float f2, charstring f3, integer f4, integer f5 } template recT temp1:= { f1:= temp2.f1, f2:= 1.1, f3:= "ERIXON", f4:= 1, f5:= 2 }; template recT temp2:= { f1:= temp1.f1, f2:= 1.1, f3:= "ERIXON", f4:= 1, f5:= 2 }; } (?im)error.+?Circular.+?reference (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Infinite recursive loops in templates/values - cross three steps long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer f1, float f2, charstring f3, integer f4, integer f5 } // TR 696 template recT temp1:= { f1:= temp2.f1, f2:= 1.1, f3:= "ERIXON", f4:= 1, f5:= 2 }; template recT temp2:= { f1:= temp2.f4, f2:= 1.1, f3:= "ERIXON", f4:= temp1.f1, f5:= 2 }; } (?im)error.+?Circular.+?reference (?is)\berror: (?im)error.+?Circular.+?reference :exmp. .*---------------------------------------------------------------------* :h4.Infinite recursive loops in templates/values - cross four steps long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer f1, float f2, charstring f3, integer f4, integer f5 } // TR 697 template recT temp1:= { f1:= temp2.f1, f2:= 1.1, f3:= "ERIXON", f4:= 1, f5:= temp1.f1 }; template recT temp2:= { f1:= temp2.f4, f2:= 1.1, f3:= "ERIXON", f4:= temp1.f5, f5:= 2 }; } (?im)error.+?Circular.+?reference (?is)\berror: (?im)error :exmp. .*---------------------------------------------------------------------* :h4.Infinite recursive loops in templates/values - double cross four steps long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer f1, float f2, charstring f3, integer f4, integer f5 } template recT temp1:= { f1:= temp2.f1, f2:= 1.1, f3:= "ERIXON", f4:= 1, f5:= 7 }; template recT temp2:= { f1:= temp3.f4, f2:= 1.1, f3:= "ERIXON", f4:= 2, f5:= 2 }; template recT temp3:= { f1:= 1, f2:= 1.1, f3:= "ERIXON", f4:= temp1.f1, f5:= 2 }; } (?im)error.+?Circular.+?reference (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.Recursive loops in modified template chains .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/22. Strategy: a modified template shall not refer to itself, either directly or indirectly, that is recursive derivation is not allowed. All occurances shall be tested, where such a notation can be used. Tested: - 1, 2 and 3 steps long modified templates in definition part .*---------------------------------------------------------------------* :h4.Recursive loops in modified template chains - one step long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer f1, float f2, charstring f3, integer f4, integer f5 } template recT temp1:= { f1:= 1, f2:= 1.1, f3:= "ERIXON", f4:= 1, f5:= 7 }; template recT temp2 modifies temp1:= { f1:= temp2.f1, f4:= 6}; } (?im)error.+?Circular.+?reference (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Recursive loops in modified template chains - two steps long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer f1, float f2, charstring f3, integer f4, integer f5 } template recT temp1:= { f1:= 1, f2:= 1.1, f3:= "ERIXON", f4:= 1, f5:= 7 }; // TR 696 template recT temp2 modifies temp1:= { f1:= temp2.f4, f4:= temp2.f1}; } (?im)error.+?Circular.+?reference (?is)\berror: (?im)error.+?Circular.+?reference :exmp. .*---------------------------------------------------------------------* :h4.Recursive loops in modified template chains - three steps long (in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type record recT { integer f1, float f2, charstring f3, integer f4, integer f5 } // TR 696 template recT temp1:= { f1:= 1, f2:= 1.1, f3:= "ERIXON", f4:= 1, f5:= 7 }; template recT temp2 modifies temp1:= { f1:= temp2.f4, f4:= temp2.f5, f5:= temp2.f1}; } (?im)error.+?Circular.+?reference (?is)\berror: (?im)error.+?Circular.+?reference :exmp. .*---------------------------------------------------------------------* :h3.Value Overflows shall be detected if possible in compile time .*---------------------------------------------------------------------* This test case group covers the requirement SA-6/23. Strategy: SA shall detect any value overflow caused by implementation (for example integer value overflow, assigned number of an enumerated identifier is greater than the MAX_INT) All occurances shall be tested, where such a notation can be used. Tested: :list. :li D='-'.simple integer constant and float constant overflows in definition part, control part and function :li D='-'.simple integer variables and float variables overflows in control part and function :li D='-'.integer overflowing in definition of an enumerated type :li D='-'.float overflowing when redefines a timer at start (in control part and function) :elist. .*---------------------------------------------------------------------* :h4.Value Overflows shall be detected if possible in compile time - integer Overflow (enumerated in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { type enumerated enumT { ONE(1), TWO(2), HUGE(99999999999999999999999999999)}; } (?is)\berror: The numeric value of enumeration `HUGE' \(99999999999999999999999999999\) is too large for being represented in memory :exmp. .*---------------------------------------------------------------------* :h4.Value Overflows shall be detected if possible in compile time - simple float Overflow (const in def.part) .*---------------------------------------------------------------------* :xmp tab=0. module x { // TR 673: fatal error on value overflows const float f:= 9.1E+999; } (?im)error.+?Overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value Overflows shall be detected if possible in compile time - simple float Overflow (const in control part) TR 673: fatal error on value overflows .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ const float f:= 9.1E+999; } } (?im)error.+?Overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value Overflows shall be detected if possible in compile time - simple float Overflow (const in function) TR 673: fatal error on value overflows .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ const float f:= 9.1E+999; } } (?im)error.+?Overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value Overflows shall be detected if possible in compile time - simple float Overflow (variable in control part) TR 673: fatal error on value overflows .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ var float f:= 9.1E+999; } } (?im)error.+?Overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value Overflows shall be detected if possible in compile time - simple float Overflow (variable in function) TR 673: fatal error on value overflows .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ var float f:= 9.1E+999; } } (?im)error.+?Overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value Overflows shall be detected if possible in compile time - float Overflow (timer start in control part) TR 673: fatal error on value overflows .*---------------------------------------------------------------------* :xmp tab=0. module x { control{ timer T1:= 500.0; T1.start( 9.1E+999); } } (?im)error.+?Overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Value Overflows shall be detected if possible in compile time - float Overflow (timer start in function) TR 673: fatal error on value overflows .*---------------------------------------------------------------------* :xmp tab=0. module x { function myFunct(){ timer T1:= 500.0; T1.start( 9.1E+999); } } (?im)error.+?Overflow (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h4.Constant folding - indexed arrays .*---------------------------------------------------------------------* :xmp tab=0. module x { control { const integer c_array1[4] := { 1,2,3,4}; const integer c_array2[4] := { 1,2,3,4}; const integer c_array3[4] := { 4,3,2,1}; const integer c_array4_ind[4] := { [0] := 1, [1] := 2, [2] := 3, [3] := 4}; const integer c_array5_ind[4] := { [3] := 4, [1] := 2, [2] := 3, [0] := 1}; var integer vl_array5[4] := { 1,2,3,4}; var boolean b := false; if(c_array1 == c_array1) {b:= true;} else {b := false;} if({1,2,3,4} == c_array1) {b:= true;} else {b := false;} if(c_array1 == {1,2,3,4}) {b:= true;} else {b := false;} if(c_array1 == c_array2) {b:= true;} else {b := false;} if(c_array4_ind == c_array4_ind) {b:= true;} else {b := false;} if(c_array1 == c_array4_ind) {b:= true;} else {b := false;} if(c_array4_ind == c_array1) {b:= true;} else {b := false;} if({ [0] := 1, [1] := 2, [2] := 3, [3] := 4} == c_array4_ind) {b:= true;} else {b := false;} if(c_array4_ind == { [0] := 1, [1] := 2, [2] := 3, [3] := 4}) {b:= true;} else {b := false;} if(c_array4_ind == c_array5_ind) {b:= true;} else {b := false;} if(vl_array5 == c_array1) {b:= true;} else {b := false;} } } (?im)warning: Control never reaches this code because of previous effective condition\(s\) :exmp. .*---------------------------------------------------------------------* :h4.Constant folding - indexed record of .*---------------------------------------------------------------------* :xmp tab=0. module x { type record of integer recof; control { const recof c_r1 := { 1,2,3,4}; const recof c_r2 := { 1,2,3,4}; const recof c_r3 := { 4,3,2,1}; const recof c_r4_ind := { [0] := 1, [1] := 2, [2] := 3, [3] := 4}; const recof c_r5_ind := { [3] := 1, [1] := 2, [2] := 3, [0] := 4}; const recof c_r6_ind := { [3] := 4, [1] := 2, [2] := 3, [0] := 1}; const recof c_r8_ind := { [0] := 1, [1] := 2, [2] := 3, [3] := 4}; var recof vl_r7_ind := { [3] := 4, [1] := 2}; var recof vl_r10 := { 1,2,3,4}; var recof vl_r11 := { 1,2,3,4}; var boolean b := false; if(c_r1 == c_r1) {b:= true;} else {b:= false;} if(c_r1 == c_r2) {b:= true;} else {b:= false;} if(c_r4_ind == c_r4_ind) {b:= true;} else {b:= false;} if(c_r1 == c_r4_ind) {b:= true;} else {b:= false;} if(c_r4_ind == c_r1) {b:= true;} else {b:= false;} if(c_r1 == c_r6_ind) {b:= true;} else {b:= false;} if(c_r1 != vl_r7_ind) {b:= true;} else { b:= false;} if(c_r4_ind == c_r8_ind) {b:= true;} else {b:= false;} if(vl_r10 == vl_r11) {b:= true;} else {b:= false;} } } (?im)warning: Control never reaches this code because of previous effective condition\(s\) :exmp. .*---------------------------------------------------------------------* :h4.Constant folding - indexed set of .*---------------------------------------------------------------------* :xmp tab=0. module x { type set of integer mysetof; control { const mysetof c_s1 := {1,2,3,4}; const mysetof c_s2 := {4,3,2,1}; const mysetof c_s3 := {1,3,2,4}; const mysetof c_s4 := {1,2,3,4,5}; const mysetof c_s5 := {0,1,2,3,4}; const mysetof c_s6 := {0,1,2,3,4,5} const mysetof c_s1_ind := {[0] := 1,[1] := 2,[2] := 3, [3] := 4}; const mysetof c_s2_ind := {[0] := 1,[3] := 4,[2] := 3, [1] := 2}; const mysetof c_s3_ind := {[0] := 2,[3] := 1,[2] := 3, [1] := 4}; var mysetof vl_s1 := {1,2,3,4}; var boolean b := false; if(c_s1 == c_s1) {b:= true;} else {b:= false;} if(c_s1 == {1,2,3,4}) {b:= true;} else {b:= false;} if({1,2,3,4} == c_s1) {b:= true;} else {b:= false;} if(c_s1 == {[0] := 1,[1] := 2,[2] := 3, [3] := 4}) {b:= true;} else {b:= false;} if({[0] := 1,[1] := 2,[2] := 3, [3] := 4} == c_s1) {b:= true;} else {b:= false;} if(c_s1 == c_s1_ind) {b:= true;} else {b:= false;} if(c_s1_ind == c_s1) {b:= true;} else {b:= false;} if(c_s1_ind == c_s2_ind) {b:= true;} else {b:= false;} if(c_s1_ind == c_s3_ind) {b:= true;} else {b:= false;} if(c_s1 == c_s3_ind) {b:= true;} else {b:= false;} if(c_s2_ind == c_s3_ind) {b:= true;} else {b:= false;} if(c_s1 == vl_s1) {b:= true;} else {b:= false;} if(vl_s1 == c_s1) {b:= true;} else {b:= false;} if(c_s1 == c_s2) {b:= true;} else {b:= false;} if(c_s1 == c_s3) {b:= true;} else {b:= false;} if(c_s1 != c_s4) {b:= true;} else {b:= false;} if(c_s1 != c_s5) {b:= true;} else {b:= false;} if(c_s1 != c_s6) {b:= true;} else {b:= false;} if(c_s5 != c_s6) {b:= true;} else {b:= false;} } } (?im)warning: Control never reaches this code because of previous effective condition\(s\) :exmp. .*---------------------------------------------------------------------* :h4.Invalid access to not-selected union field shall cause dyanimc testcase error - access to non-actual union element 1 TR HN30230: Value of union is set to unbount if other union possibilities are tried to be accessed. .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type union UnionType1{ UnionType2 girl, integer numero } type union UnionType2{ Emma emma, Eszter eszter } type record Emma { charstring name} type record Eszter { charstring name} type component dummy_CT {} testcase tc_UnboundUnion () runs on dummy_CT{ var UnionType1 vl_e := {girl := {emma := {name := "Emma"}}}; log(log2str("numero: ",vl_e.numero)); } control { execute(tc_UnboundUnion()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] Temp (?im)Dynamic test case error: Using non-selected field numero in a value of union type @Temp.UnionType1. :exmp. .*---------------------------------------------------------------------* :h4.Invalid access to not-selected union field shall cause dyanimc testcase error - access to non-actual union element 2 TR HN30230: Value of union is set to unbount if other union possibilities are tried to be accessed. .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type union UnionType1{ UnionType2 girl, integer numero } type union UnionType2{ Emma emma, Eszter eszter } type record Emma { charstring name} type record Eszter { charstring name} type component dummy_CT {} testcase tc_UnboundUnion () runs on dummy_CT{ var UnionType1 vl_e := {girl := {emma := {name := "Emma"}}}; var integer temp := vl_e.numero; } control { execute(tc_UnboundUnion()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] Temp (?im)Dynamic test case error: Using non-selected field numero in a value of union type @Temp.UnionType1. :exmp. .*---------------------------------------------------------------------* :h4.Invalid access to not-selected union field shall cause dyanimc testcase error - access to non-actual union element 3 TR HN30230: Value of union is set to unbount if other union possibilities are tried to be accessed. .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type union UnionType1{ UnionType2 girl, integer numero } type union UnionType2{ Emma emma, Eszter eszter } type record Emma { charstring name} type record Eszter { charstring name} type component dummy_CT {} testcase tc_UnboundUnion () runs on dummy_CT{ var UnionType1 vl_e := {girl := {emma := {name := "Emma"}}}; var integer temp; temp := vl_e.numero; } control { execute(tc_UnboundUnion()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] Temp (?im)Dynamic test case error: Using non-selected field numero in a value of union type @Temp.UnionType1. :exmp. .*---------------------------------------------------------------------* :h4.Invalid access to not-selected union field shall cause dyanimc testcase error - access to non-actual union element 4 TR HN30230: Value of union is set to unbount if other union possibilities are tried to be accessed. .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type union UnionType1{ UnionType2 girl, integer numero } type union UnionType2{ Emma emma, Eszter eszter } type record Emma { charstring name} type record Eszter { charstring name} function dummy(integer par) { } type component dummy_CT {} testcase tc_UnboundUnion () runs on dummy_CT{ var UnionType1 vl_e := {girl := {emma := {name := "Emma"}}}; dummy(vl_e.numero); } control { execute(tc_UnboundUnion()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] Temp (?im)Dynamic test case error: Using non-selected field numero in a value of union type @Temp.UnionType1. :exmp. .*---------------------------------------------------------------------* :h4.Invalid access to not-selected union field shall cause dyanimc testcase error - access to non-actual union element 5 TR HN30230: Value of union is set to unbount if other union possibilities are tried to be accessed. .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type union UnionType1{ UnionType2 girl, integer numero } type union UnionType2{ Emma emma, Eszter eszter } type record Emma { charstring name} type record Eszter { charstring name} type component dummy_CT {} testcase tc_UnboundUnion () runs on dummy_CT{ var UnionType1 vl_e := {girl := {emma := {name := "Emma"}}}; var integer v[5]; v[vl_e.numero] := 1; } control { execute(tc_UnboundUnion()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] Temp (?im)Dynamic test case error: Using non-selected field numero in a value of union type @Temp.UnionType1. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound field .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type record recordInner {integer f1, integer f2}; type record recordOuter {recordInner f1, integer f2}; function problem() { template recordOuter vt_temp := {f2 := 5}; template integer t_temp := vt_temp.f1.f1; } } (?im)\berror\b.+?Reference.+?unbound.*?field.+?f1 :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound component variable (TR no. HO24162, HO23581) .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type record of integer IList; type component C { var integer i; var IList ilist; } function problem() runs on C { action(isbound(i), " i: ", i); } } module ModuleB { import from ModuleA all; function problem() runs on C { action(isbound(i), " i: ", i); action(isbound(ilist[i]), " ilist[i]: ", ilist[i]); } } (?is)\berror: :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound field (TR no. HN91136) .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type union bubu { integer a, integer b } type record of integer intrec; control { var bubu i := { a:= 2}; action(isbound(i.b)); var intrec vl_rec := {}; action(isbound(vl_rec[2])); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Test execution summary: 0 test case was executed. Overall verdict: none :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound bitstring bit .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type component dummy_CT {} testcase tc_temp () runs on dummy_CT{ var bitstring bstr; log(isvalue(bstr[0])); } control { execute(tc_temp()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Dynamic test case error: Accessing an element of an unbound bitstring value. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound charstring bit .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type component dummy_CT {} testcase tc_temp () runs on dummy_CT{ var charstring cstr; log(isvalue(cstr[0])); } control { execute(tc_temp()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Dynamic test case error: Accessing an element of an unbound charstring value. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound hexstring octet .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type component dummy_CT {} testcase tc_temp () runs on dummy_CT{ var hexstring hstr; log(isvalue(hstr[0])); } control { execute(tc_temp()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Dynamic test case error: Accessing an element of an unbound hexstring value. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound octetstring octet .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type component dummy_CT {} testcase tc_temp () runs on dummy_CT{ var octetstring ostr; log(isvalue(ostr[0])); } control { execute(tc_temp()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Dynamic test case error: Accessing an element of an unbound octetstring value. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound universal charstring bit .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type component dummy_CT {} testcase tc_temp () runs on dummy_CT{ var universal charstring cstr; log(isvalue(cstr[0])); } control { execute(tc_temp()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Dynamic test case error: Accessing an element of an unbound universal charstring value. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound union field .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type union tunion { integer x1, integer x2 } type component dummy_CT {} testcase tc_temp () runs on dummy_CT{ var tunion temp := {x1 := 1}; log(isvalue(temp.x2)); } control { execute(tc_temp()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Dynamic test case error: Using non-selected field x2 in a value of union type @ModuleA.tunion. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound record of element .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type record of integer t_recof; type component dummy_CT {} testcase tc_temp () runs on dummy_CT{ var t_recof temp; log(isvalue(temp[0])); } control { execute(tc_temp()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Dynamic test case error: Accessing an element in an unbound value of type @PreGenRecordOf.PREGEN_RECORD_OF_INTEGER. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound record of element (overflow) .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type record of integer t_recof; type component dummy_CT {} testcase tc_temp () runs on dummy_CT{ var t_recof temp := {[1] := 1}; log(isvalue(temp[10])); } control { execute(tc_temp()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Dynamic test case error: Index overflow in a value of type @PreGenRecordOf.PREGEN_RECORD_OF_INTEGER: The index is 10, but the value has only 2 elements. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound set of element .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type set of integer t_setof; type component dummy_CT {} testcase tc_temp () runs on dummy_CT{ var t_setof temp; log(isvalue(temp[0])); } control { execute(tc_temp()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Dynamic test case error: Accessing an element in an unbound value of type @PreGenRecordOf.PREGEN_SET_OF_INTEGER. :exmp. .*---------------------------------------------------------------------* :h3.TTCN-3::Referencing a unbound set of element (overflow) .*---------------------------------------------------------------------* :xmp tab=0. module ModuleA { type set of integer t_setof; type component dummy_CT {} testcase tc_temp () runs on dummy_CT{ var t_setof temp := {[1] := 1}; log(isvalue(temp[10])); } control { execute(tc_temp()); } } [MODULE_PARAMETERS] [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" LogFileSize := 10 LogFileNumber := 10 DiskFullAction := error FileMask := LOG_ALL ConsoleMask := WARNING | ERROR | TESTCASE | STATISTICS [EXECUTE] ModuleA (?im)Dynamic test case error: Index overflow in a value of type @PreGenRecordOf.PREGEN_SET_OF_INTEGER: The index is 10, but the value has only 2 elements. :exmp. .*---------------------------------------------------------------------* :h3.Adhoc:: ispresent() isbound() DTEs .*---------------------------------------------------------------------* :xmp tab=0. module Temp { type component MyComp {} type record of charstring ROC; type record of integer ROI; type record MyRecord1 { integer i optional, float x optional, charstring c } type union MyUnion1 { ROC roc, integer i, ROI roi, MyRecord1 r } const MyUnion1 c_myunion2:= { i:= 5 } testcase tc_runtimeDivisionByZero_ispresent() runs on MyComp { var MyUnion1 vl_u:= c_myunion2; if(ispresent(vl_u)) {setverdict(pass)} else {setverdict(fail)} if(ispresent(vl_u.i)){setverdict(pass)}else {setverdict(fail)} if(ispresent(vl_u.i/2)){setverdict(pass)}else {setverdict(fail)} if(ispresent(vl_u.i*0)){setverdict(pass)}else {setverdict(fail)} if(ispresent(vl_u.i/(vl_u.i-5))){setverdict(fail)}else {setverdict(pass)} //DTE - OK } testcase tc_runtimeDivisionByZero() runs on MyComp { var MyUnion1 vl_u:= c_myunion2; if(isbound(vl_u)) {setverdict(pass)} else {setverdict(fail)} if(isbound(vl_u.i)){setverdict(pass)}else {setverdict(fail)} if(isbound(vl_u.i/2)){setverdict(pass)}else {setverdict(fail)} if(isbound(vl_u.i*0)){setverdict(pass)}else {setverdict(fail)} if(isbound(vl_u.i/(vl_u.i-5))){setverdict(fail)}else {setverdict(pass)} //DTE - OK } control { execute(tc_runtimeDivisionByZero()); execute(tc_runtimeDivisionByZero_ispresent()); } } [LOGGING] LogSourceInfo := Yes Logfile := "Temp%i.log" FileMask := LOG_ALL ConsoleMask := LOG_ALL [EXECUTE] Temp (?im)Dynamic test case error: Integer division by zero. :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 22 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.