projects / deliverable / titan.core.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #27 from BotondBaranyi/master
[deliverable/titan.core.git] / regression_test / templateBitstr / TtemplateBitstr.ttcn
CommitLineData
970ed795 1/******************************************************************************
d44e3c4f 2 * Copyright (c) 2000-2016 Ericsson Telecom AB
970ed795
EL		 3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html
d44e3c4f 7 *
8 * Contributors:
9 * Balasko, Jeno
10 * Kovacs, Ferenc
11 * Raduly, Csaba
12 * Szabados, Kristof
13 * Szabo, Janos Zoltan – initial implementation
14 *
970ed795
EL		 15 ******************************************************************************/
16module TtemplateBitstr {
17type component templateBitstr_mycomp {};
18type record templateBitstr_rec {
19 bitstring x1,
20 bitstring x2,
21 bitstring x3 optional };
22template templateBitstr_rec templateBitstr_tSpec :={ //specific values
23 x1:='001'B,
24 x2:='010'B,
25 x3:='100'B };
26template templateBitstr_rec templateBitstr_tList :={ //specific value and value list
27 x1:='001'B,
28 x2:=('010'B,'011'B,'1100'B),
29 x3:='100'B };
30template templateBitstr_rec templateBitstr_tComp :={ //specific value and compl. list
31 x1:='001'B,
32 x2:=complement ('11'B,'00'B,'1000'B),
33 x3:='100'B };
34template templateBitstr_rec templateBitstr_tOmit :={ //omitting values
35 x1:='001'B,
36 x2:='010'B,
37 x3:=omit } ;
38template templateBitstr_rec templateBitstr_tAny :={ //specific and any value
39 x1:='001'B,
40 x2:='010'B,
41 x3:=? } ;
42template templateBitstr_rec templateBitstr_tAnyorNone :={ //specific and AnyorNone value
43 x1:='001'B,
44 x2:='010'B,
45 x3:=* };
46template templateBitstr_rec templateBitstr_tLength1 :={ //specific value and fix length
47 x1:='001'B,
48 x2:='010'B,
49 x3:=* length(3) };
50template templateBitstr_rec templateBitstr_tLength2 :={ //specific value and length (range)
51 x1:='001'B,
52 x2:='010'B,
53 x3:=? length(2..4) };
54template templateBitstr_rec templateBitstr_tLength3 :={ //specific value and length (range, infinity)
55 x1:='001'B,
56 x2:='010'B,
57 x3:=? length(2..infinity) };
58template templateBitstr_rec templateBitstr_tIfpresent :={ //specific value and ifpresent
59 x1:='001'B,
60 x2:='010'B,
61 x3:='100'B ifpresent };
62template templateBitstr_rec templateBitstr_tLengthIfp :={ //specific value and fix length and ifpresent
63 x1:='001'B,
64 x2:='010'B,
65 x3:= ? length(3) ifpresent};
66template templateBitstr_rec templateBitstr_tAnyEl :={ //specific value and any element inside value
67 x1:='001'B,
68 x2:='010'B,
69 x3:='10?'B } ;
70template templateBitstr_rec templateBitstr_tAnyorNoneEl :={ //specific value and Any number of elements or none inside value
71 x1:='001'B,
72 x2:='010'B,
73 x3:='10*'B };
74
75 template bitstring t_param1(templateBitstr_rec par) := substr(par.x1, 0, 1); // parameterised template
76
77testcase templateBitstrSpec() runs on templateBitstr_mycomp {
78var templateBitstr_rec x1,x2; //specific value
79x1:={ x1:='001'B, x2:='010'B, x3:='100'B };
80x2:={ x1:='00'B, x2:='010'B, x3:='100'B };
81//match
82if (match(x1,templateBitstr_tSpec)) {setverdict(pass);}
83 else {setverdict(fail);}
84//no match
85if (not(match(x2,templateBitstr_tSpec))) {setverdict(pass);}
86 else {setverdict(fail);}
87}
88
89testcase templateBitstrList() runs on templateBitstr_mycomp {
90var templateBitstr_rec x1,x2,x3; //value list
91x1:={ x1:='001'B, x2:='010'B, x3:='100'B };
92x2:={ x1:='001'B, x2:='00'B, x3:='100'B };
93x3:={ x1:='1'B, x2:='010'B, x3:='100'B };
94//match
95if (match(x1,templateBitstr_tList)) {setverdict(pass);}
96 else {setverdict(fail);}
97//no match: out of list
98if (not(match(x2,templateBitstr_tList))) {setverdict(pass);}
99 else {setverdict(fail);}
100//no match: other field
101if (not(match(x3,templateBitstr_tList))) {setverdict(pass);}
102 else {setverdict(fail);}
103}
104
105testcase templateBitstrComp() runs on templateBitstr_mycomp {
106var templateBitstr_rec x1,x2,x3; //complemented list
107x1:={ x1:='001'B, x2:='010'B, x3:='100'B };
108x2:={ x1:='001'B, x2:='11'B, x3:='100'B };
109x3:={ x1:='11'B, x2:='010'B, x3:='100'B };
110//match
111if (match(x1,templateBitstr_tComp)) {setverdict(pass);}
112 else {setverdict(fail);}
113//no match: in the list
114if (not(match(x2,templateBitstr_tComp))) {setverdict(pass);}
115 else {setverdict(fail);}
116//no match: other field
117if (not(match(x3,templateBitstr_tComp))) {setverdict(pass);}
118 else {setverdict(fail);}
119}
120
121testcase templateBitstrOmit() runs on templateBitstr_mycomp {
122var templateBitstr_rec x1,x2,x3; //omitting value
123x1:={ x1:='001'B, x2:='010'B, x3:=omit };
124x2:={ x1:='001'B, x2:='010'B, x3:='000'B };
125x3:={ x1:='00'B, x2:='010'B, x3:=omit };
126//match
127if (match(x1,templateBitstr_tOmit)) {setverdict(pass);}
128 else {setverdict(fail);}
129//no match: not omitted
130if (not(match(x2,templateBitstr_tOmit))) {setverdict(pass);}
131 else {setverdict(fail);}
132//no match: other field
133if (not(match(x3,templateBitstr_tOmit))) {setverdict(pass);}
134 else {setverdict(fail);}
135}
136
137testcase templateBitstrAny() runs on templateBitstr_mycomp {
138var templateBitstr_rec x1,x2,x3; //any value
139x1:={ x1:='001'B, x2:='010'B, x3:='111'B };
140x2:={ x1:='001'B, x2:='010'B, x3:=omit };
141x3:={ x1:='0'B, x2:='010'B, x3:='10'B };
142//match
143if (match(x1,templateBitstr_tAny)) {setverdict(pass);}
144 else {setverdict(fail);}
145//no match: field omitted
146if (not(match(x2,templateBitstr_tAny))) {setverdict(pass);}
147 else {setverdict(fail);}
148//no match: other field
149if (not(match(x3,templateBitstr_tAny))) {setverdict(pass);}
150 else {setverdict(fail);}
151}
152
153testcase templateBitstrAnyorNone() runs on templateBitstr_mycomp {
154var templateBitstr_rec x1,x2,x3; //AnyorNone value
155x1:={ x1:='001'B, x2:='010'B, x3:=omit };
156x2:={ x1:='001'B, x2:='010'B, x3:='100'B };
157x3:={ x1:='1'B, x2:='010'B, x3:=omit };
158//match: omitted
159if (match(x1,templateBitstr_tAnyorNone)) {setverdict(pass);}
160 else {setverdict(fail);}
161//match: value
162if (match(x2,templateBitstr_tAnyorNone)) {setverdict(pass);}
163 else {setverdict(fail);}
164//no match: other field
165if (not(match(x3,templateBitstr_tAnyorNone))) {setverdict(pass);}
166 else {setverdict(fail);}
167}
168
169testcase templateBitstrLength1() runs on templateBitstr_mycomp {
170var templateBitstr_rec x1,x2,x3,x4; //length (fix)
171x1:={ x1:='001'B, x2:='010'B, x3:='111'B };
172x2:={ x1:='001'B, x2:='010'B, x3:=omit };
173x3:={ x1:='001'B, x2:='010'B, x3:='10'B };
174x4:={ x1:='0010'B, x2:='010'B, x3:='111'B };
175//match: proper length
176if (match(x1,templateBitstr_tLength1)) {setverdict(pass);}
177 else {setverdict(fail);}
178//match: omitted
179if (match(x2,templateBitstr_tLength1)) {setverdict(pass);}
180 else {setverdict(fail);}
181// no match: not proper length
182if (not(match(x3,templateBitstr_tLength1))) {setverdict(pass);}
183 else {setverdict(fail);}
184//no match: other field
185if (not(match(x4,templateBitstr_tLength1))) {setverdict(pass);}
186 else {setverdict(fail);}
187}
188
189testcase templateBitstrLength2() runs on templateBitstr_mycomp {
190var templateBitstr_rec x1,x2,x3; //length (range)
191x1:={ x1:='001'B, x2:='010'B, x3:='111'B };
192x2:={ x1:='001'B, x2:='010'B, x3:='1'B };
193x3:={ x1:='0010'B, x2:='010'B, x3:='111'B };
194//match
195if (match(x1,templateBitstr_tLength2)) {setverdict(pass);}
196 else {setverdict(fail);}
197// no match: not proper length
198if (not(match(x2,templateBitstr_tLength2))) {setverdict(pass);}
199 else {setverdict(fail);}
200//no match: other field
201if (not(match(x3,templateBitstr_tLength2))) {setverdict(pass);}
202 else {setverdict(fail);}
203}
204
205testcase templateBitstrLength3() runs on templateBitstr_mycomp {
206var templateBitstr_rec x1,x2,x3; //length (range, infinity)
207x1:={ x1:='001'B, x2:='010'B, x3:='111'B };
208x2:={ x1:='001'B, x2:='010'B, x3:='1'B };
209x3:={ x1:='0010'B, x2:='010'B, x3:='111'B };
210//match
211if (match(x1,templateBitstr_tLength3)) {setverdict(pass);}
212 else {setverdict(fail);}
213// no match: not proper length
214if (not(match(x2,templateBitstr_tLength3))) {setverdict(pass);}
215 else {setverdict(fail);}
216//no match: other field
217if (not(match(x3,templateBitstr_tLength3))) {setverdict(pass);}
218 else {setverdict(fail);}
219}
220
221testcase templateBitstrIfpresent() runs on templateBitstr_mycomp {
222var templateBitstr_rec x1,x2,x3,x4; //ifpresent
223x1:={ x1:='001'B, x2:='010'B, x3:='100'B };
224x2:={ x1:='001'B, x2:='010'B, x3:=omit };
225x3:={ x1:='001'B, x2:='010'B, x3:='000'B };
226x4:={ x1:='00'B, x2:='010'B, x3:=omit };
227//match: present and match
228if (match(x1,templateBitstr_tIfpresent)) {setverdict(pass);}
229 else {setverdict(fail);}
230//match: not present
231if (match(x2,templateBitstr_tIfpresent)) {setverdict(pass);}
232 else {setverdict(fail);}
233//no match: present and not match
234if (not(match(x3,templateBitstr_tIfpresent))) {setverdict(pass);}
235 else {setverdict(fail);}
236//no match: other field
237if (not(match(x4,templateBitstr_tIfpresent))) {setverdict(pass);}
238 else {setverdict(fail);}
239}
240
241testcase templateBitstrLengthIfp() runs on templateBitstr_mycomp {
242var templateBitstr_rec x1,x2,x3,x4; //length (fix), ifpresent
243x1:={ x1:='001'B, x2:='010'B, x3:='111'B };
244x2:={ x1:='001'B, x2:='010'B, x3:=omit };
245x3:={ x1:='001'B, x2:='010'B, x3:='10'B };
246x4:={ x1:='0010'B, x2:='010'B, x3:='111'B };
247//match: proper length
248if (match(x1,templateBitstr_tLengthIfp)) {setverdict(pass);}
249 else {setverdict(fail);}
250//match: omitted
251if (match(x2,templateBitstr_tLengthIfp)) {setverdict(pass);}
252 else {setverdict(fail);}
253// no match: not proper length
254if (not(match(x3,templateBitstr_tLengthIfp))) {setverdict(pass);}
255 else {setverdict(fail);}
256//no match: other field
257if (not(match(x4,templateBitstr_tLengthIfp))) {setverdict(pass);}
258 else {setverdict(fail);}
259}
260
261testcase templateBitstrAnyEl() runs on templateBitstr_mycomp {
262var templateBitstr_rec x1,x2,x3,x4,x5; //any element
263x1:={ x1:='001'B, x2:='010'B, x3:='101'B };
264x2:={ x1:='001'B, x2:='010'B, x3:='10'B };
265x3:={ x1:='001'B, x2:='010'B, x3:='1000'B };
266x4:={ x1:='001'B, x2:='010'B, x3:='001'B };
267x5:={ x1:='0'B, x2:='010'B, x3:='101'B };
268//match
269if (match(x1,templateBitstr_tAnyEl)) {setverdict(pass);}
270 else {setverdict(fail);}
271//no match: no element
272if (not(match(x2,templateBitstr_tAnyEl))) {setverdict(pass);}
273 else {setverdict(fail);}
274//no match: two element
275if (not(match(x3,templateBitstr_tAnyEl))) {setverdict(pass);}
276 else {setverdict(fail);}
277//no match: wrong element
278if (not(match(x4,templateBitstr_tAnyEl))) {setverdict(pass);}
279 else {setverdict(fail);}
280//no match: other field
281if (not(match(x5,templateBitstr_tAnyEl))) {setverdict(pass);}
282 else {setverdict(fail);}
283}
284
285testcase templateBitstrAnyorNoneEl() runs on templateBitstr_mycomp {
286var templateBitstr_rec x1,x2,x3,x4,x5; //Any number of elements or none
287x1:={ x1:='001'B, x2:='010'B, x3:='10'B };
288x2:={ x1:='001'B, x2:='010'B, x3:='100'B };
289x3:={ x1:='001'B, x2:='010'B, x3:='1011'B };
290x4:={ x1:='001'B, x2:='010'B, x3:='110'B };
291x5:={ x1:='1'B, x2:='010'B, x3:='100'B };
292//match: no element
293if (match(x1,templateBitstr_tAnyorNoneEl)) {setverdict(pass);}
294 else {setverdict(fail);}
295//match: one element
296if (match(x2,templateBitstr_tAnyorNoneEl)) {setverdict(pass);}
297 else {setverdict(fail);}
298//match: two element
299if (match(x3,templateBitstr_tAnyorNoneEl)) {setverdict(pass);}
300 else {setverdict(fail);}
301//no match: other element
302if (not(match(x4,templateBitstr_tAnyorNoneEl))) {setverdict(pass);}
303 else {setverdict(fail);}
304//no match: other field
305if (not(match(x5,templateBitstr_tAnyorNoneEl))) {setverdict(pass);}
306 else {setverdict(fail);}
307}
308
309testcase CR_TR00018474() runs on templateBitstr_mycomp {
310 // Indexing of string template variables.
311 var template bitstring vtb1 := '0011110000'B
312 var template bitstring vtb2 := '0*?1'B // It's a pattern, cannot be indexed, runtime error.
313 vtb1[0] := '1'B
314 if (match('1011110000'B, vtb1)) { setverdict(pass) } else { setverdict(fail) }
315 vtb1[0] := '1'B // Indexed assignment notation cannot be used here.
316 vtb1[1] := '0'B // Still works, nothing special.
317 if (match('1011110000'B, vtb1)) { setverdict(pass) } else { setverdict(fail) }
318}
319
320control {
321 execute(templateBitstrSpec());
322 execute(templateBitstrList());
323 execute(templateBitstrComp());
324 execute(templateBitstrOmit());
325 execute(templateBitstrAny());
326 execute(templateBitstrAnyorNone());
327 execute(templateBitstrLength1());
328 execute(templateBitstrLength2());
329 execute(templateBitstrLength3());
330 execute(templateBitstrIfpresent());
331 execute(templateBitstrLengthIfp());
332 execute(templateBitstrAnyEl());
333 execute(templateBitstrAnyorNoneEl());
334 execute(CR_TR00018474());
335}
336}
Titan Core - Deliverables
This page took 0.036615 seconds and 5 git commands to generate.