projects / deliverable / titan.core.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Last sync 2016.04.01
[deliverable/titan.core.git] / regression_test / arrayOper / TarrayOper.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 * Beres, Szabolcs
11 * Cserveni, Akos
12 * Forstner, Matyas
13 * Godar, Marton
14 * Raduly, Csaba
15 * Szabados, Kristof
16 * Szabo, Janos Zoltan – initial implementation
17 * Pandi, Krisztian
18 *
970ed795
EL		 19 ******************************************************************************/
20module TarrayOper {
21// ********** Type definitions *********************
22type component arrayOper_mycomp {};
23type enumerated arrayOper_myenum {xx1,xx2,xx3};
24type record arrayOper_trecord {
25 integer x1 optional,
26 float x2 };
27type record of octetstring arrayOper_trecof;
28type set arrayOper_tset {
29 integer x1,
30 float x2 optional };
31type set of charstring arrayOper_tsetof;
32type set of integer arrayOper_tsetof2;
33type union arrayOper_tunion {
34 integer x1,
35 float x2 };
36type arrayOper_tsetof2 arrayOper_triplet[3];
37type arrayOper_triplet arrayOper_triplettriplet[3];
38type record arrayOper_trecord2{
39 integer x1[3]
40};
41// *************** Constanst ***********************
42const arrayOper_trecord arrayOper_temp1:={ x1:=omit, x2:=3.4 };
43const arrayOper_trecof arrayOper_temp2:={ 'AF12'O };
44const arrayOper_tset arrayOper_temp3:={ x1:=234, x2:=1.9};
45const arrayOper_tsetof arrayOper_temp4:={"f","8"};
46const arrayOper_tunion arrayOper_temp5:={ x2:=1.3 };
47const integer arrayOper_const1[2]:={ 1,2 } //array of basic types
48const arrayOper_myenum arrayOper_const2[2]:={ xx2, xx1 }
49const arrayOper_trecord arrayOper_const4[2]:={ //array of record
50 { x1:=1, x2:=1.2 },arrayOper_temp1 };
51const arrayOper_trecof arrayOper_const6[2]:={ //array of record of
52 { '12AB'O, 'CD12'O }, arrayOper_temp2 };
53const arrayOper_tset arrayOper_const8[2]:={ //array of set
54 { x1:=2, x2:=1.3}, arrayOper_temp3 };
55const arrayOper_tsetof arrayOper_const10[2]:={ //array of set of
56 {"a","b"}, arrayOper_temp4 }; //{"f","8"},
57const arrayOper_tunion arrayOper_const12[2]:={ //array of union
58 { x1 :=3 }, arrayOper_temp5 }; //{ x2:=1.3 }
59const arrayOper_tsetof2 arrayOper_const13[3][3]:={
60{{1,2},{2,3},{3,4}},{{1,2},{4,5},{6,7}},{{2,1},{3,2},{4,3}}}
61
62testcase arrayAssign() runs on arrayOper_mycomp{
63var integer x1[2]:={ 12,34} //array of basic types
64var integer x2[2];
65var integer x3[2 .. 4]; //index ranges
66x2:={ 32, 12 };
67x3:={32,12,3};
68if (x1[0]==12) {setverdict(pass);} //at declaration
69 else {setverdict(fail);}
70if (x1[1]==34) {setverdict(pass);}
71 else {setverdict(fail);}
72if (x2[0]==32) {setverdict(pass);} //later
73 else {setverdict(fail);}
74if (x2[1]==12) {setverdict(pass);}
75 else {setverdict(fail);}
76if (x3[2]==32) {setverdict(pass);} //index ranges
77 else {setverdict(fail);}
78if (x3[3]==12) {setverdict(pass);}
79 else {setverdict(fail);}
80if (x3[4]==3) {setverdict(pass);}
81 else {setverdict(fail);}
82}
83
84testcase arrayAssignEnum() runs on arrayOper_mycomp{
85var arrayOper_myenum x1[2]:={ xx2, - } //array of enum
86var arrayOper_myenum x2[2];
87x2:={xx2,xx1};
88//at declaration
89if (x1[0]==xx2) {setverdict(pass);}
90 else {setverdict(fail);}
91//later
92if (x2[0]==xx2) {setverdict(pass);}
93 else {setverdict(fail);}
94if (x2[1]==xx1) {setverdict(pass);}
95 else {setverdict(fail);}
96}
97
98testcase arrayAssignRec() runs on arrayOper_mycomp{
99var arrayOper_trecord temp1:={ x1:=omit, x2:=3.4 };
100var arrayOper_trecord x1[2]:={ //array of record
101 { x1:=1, x2:=1.2 }, temp1 };
102var arrayOper_trecord x2[2];
103x2:={ { x1:=1, x2:=1.2 }, temp1 };
104if (x1[0].x1==1) {setverdict(pass);} //at declaration
105 else {setverdict(fail);}
106if (x1[0].x2==1.2) {setverdict(pass);}
107 else {setverdict(fail);}
108if (x1[1]==temp1) {setverdict(pass);}
109 else {setverdict(fail);}
110if (x2[0].x1==1) {setverdict(pass);} //later
111 else {setverdict(fail);}
112if (x2[0].x2==1.2) {setverdict(pass);}
113 else {setverdict(fail);}
114if (not(ispresent(x2[1].x1))) {setverdict(pass);}
115 else {setverdict(fail);}
116if (x2[1].x2==3.4) {setverdict(pass);}
117 else {setverdict(fail);}
118}
119
120testcase arrayAssignRecof() runs on arrayOper_mycomp{
121var arrayOper_trecof temp2:={'AF12'O};
122var arrayOper_trecof x1[2]:={ //array of record of
123 { '12AB'O, 'CD12'O }, temp2 };
124var arrayOper_trecof x2[2];
125x2:={ { '12AB'O, 'CD12'O }, temp2 };
126if (x1[0][0]=='12AB'O) {setverdict(pass);} //at declaration
127 else {setverdict(fail);}
128if (x1[0][1]=='CD12'O) {setverdict(pass);}
129 else {setverdict(fail);}
130if (x1[1]==temp2) {setverdict(pass);}
131 else {setverdict(fail);}
132if (x2[0][0]=='12AB'O) {setverdict(pass);} //later
133 else {setverdict(fail);}
134if (x2[0][1]=='CD12'O) {setverdict(pass);}
135 else {setverdict(fail);}
136if (x2[1][0]=='AF12'O) {setverdict(pass);}
137 else {setverdict(fail);}
138}
139
140testcase arrayAssignSet() runs on arrayOper_mycomp{
141var arrayOper_tset temp1:={ x1:=2, x2:=omit };
142var arrayOper_tset x1[2]:={ //array of set
143 { x1:=1, x2:=1.2 }, temp1 };
144var arrayOper_tset x2[2];
145x2:={ { x1:=1, x2:=1.2 }, temp1 };
146if (x1[0].x1==1) {setverdict(pass);} //at declaration
147 else {setverdict(fail);}
148if (x1[0].x2==1.2) {setverdict(pass);}
149 else {setverdict(fail);}
150if (x1[1]==temp1) {setverdict(pass);}
151 else {setverdict(fail);}
152if (x2[0].x1==1) {setverdict(pass);} //later
153 else {setverdict(fail);}
154if (x2[0].x2==1.2) {setverdict(pass);}
155 else {setverdict(fail);}
156if (x2[1].x1==2) {setverdict(pass);}
157 else {setverdict(fail);}
158if (not(ispresent(x2[1].x2))) {setverdict(pass);}
159 else {setverdict(fail);}
160}
161
162testcase arrayAssignSetof() runs on arrayOper_mycomp{
163var arrayOper_tsetof temp2:={"a","7"};
164var arrayOper_tsetof x1[2]:={ //array of set of
165 { "1", "a" }, temp2 };
166var arrayOper_tsetof x2[2];
167x2:={ { "1", "a" }, temp2 };
168if (x1[0][0]=="1") {setverdict(pass);} //at declaration
169 else {setverdict(fail);}
170if (x1[0][1]=="a") {setverdict(pass);}
171 else {setverdict(fail);}
172if (x1[1]==temp2) {setverdict(pass);}
173 else {setverdict(fail);}
174if (x2[0][0]=="1") {setverdict(pass);} //later
175 else {setverdict(fail);}
176if (x2[0][1]=="a") {setverdict(pass);}
177 else {setverdict(fail);}
178if (x2[1][0]=="a") {setverdict(pass);}
179 else {setverdict(fail);}
180if (x2[1][1]=="7") {setverdict(pass);}
181 else {setverdict(fail);}
182}
183
184testcase arrayAssignUnion() runs on arrayOper_mycomp{
185var arrayOper_tunion temp5 := {x2:=1.3}
186var arrayOper_tunion x1[2]:={ //array of union
187 { x1 :=3 }, temp5 }; //{ x2:=1.3
188var arrayOper_tunion x2[2];
189x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
190if (x1[0].x1==3) {setverdict(pass);} //at declaration
191 else {setverdict(fail);}
192if (ischosen(x1[0].x1)) {setverdict(pass);}
193 else {setverdict(fail);}
194if (not(ischosen(x1[0].x2))) {setverdict(pass);}
195 else {setverdict(fail);}
196if (x1[1]==temp5) {setverdict(pass);}
197 else {setverdict(fail);}
198if (x2[0].x1==3) {setverdict(pass);} //later
199 else {setverdict(fail);}
200if (ischosen(x2[0].x1)) {setverdict(pass);}
201 else {setverdict(fail);}
202if (not(ischosen(x2[0].x2))) {setverdict(pass);}
203 else {setverdict(fail);}
204if (x2[1].x2==1.3) {setverdict(pass);}
205 else {setverdict(fail);}
206if (ischosen(x2[1].x2)) {setverdict(pass);}
207 else {setverdict(fail);}
208if (not(ischosen(x2[1].x1))) {setverdict(pass);}
209 else {setverdict(fail);}
210}
211
212testcase arrayAssignArray() runs on arrayOper_mycomp{
213var charstring x1[2][2]:={ //array of array
214 { "1", "a" }, {"a","7"} };
215var arrayOper_tsetof x2[2];
216x2:={ { "1", "a" }, {"a","7"} };
217if (x1[0][0]=="1") {setverdict(pass);} //at declaration
218 else {setverdict(fail);}
219if (x1[0][1]=="a") {setverdict(pass);}
220 else {setverdict(fail);}
221if (x1[1][0]=="a") {setverdict(pass);}
222 else {setverdict(fail);}
223if (x1[1][1]=="7") {setverdict(pass);}
224 else {setverdict(fail);}
225if (x2[0][0]=="1") {setverdict(pass);} //later
226 else {setverdict(fail);}
227if (x2[0][1]=="a") {setverdict(pass);}
228 else {setverdict(fail);}
229if (x2[1][0]=="a") {setverdict(pass);}
230 else {setverdict(fail);}
231if (x2[1][1]=="7") {setverdict(pass);}
232 else {setverdict(fail);}
233}
234
235testcase arrayAssignSubArray() runs on arrayOper_mycomp{
236 var integer x1[4][2] := {{1,2},{3,4},{5,6},{7,8}}; //array of basic types
237 var integer x2[2][2] := {x1[0],x1[3]};
238 var integer x3[1][2] := {{x1[0][0],x1[1][0]}};
239 if(x2[0][0]==1){setverdict(pass);}
240 else {setverdict(fail);}
241 if(x2[0][1]==2){setverdict(pass);}
242 else {setverdict(fail);}
243 if(x2[1][0]==7){setverdict(pass);}
244 else {setverdict(fail);}
245 if(x2[1][1]==8){setverdict(pass);}
246 else {setverdict(fail);}
247 if(x3[0][0]==1){setverdict(pass);}
248 else {setverdict(fail);}
249 if(x3[0][1]==3){setverdict(pass);}
250 else {setverdict(fail);}
251}
252
253testcase arrayAssignRangedArray() runs on arrayOper_mycomp{
254 var integer x1[1..2][2..3]:={{1,2},{2,3}};
255 var integer x2[0..1][2..3]:={{11,22},x1[1]};
256 if(x1[1][2]==1){setverdict(pass);}
257 else{setverdict(fail);}
258 if(x1[1][3]==2){setverdict(pass);}
259 else{setverdict(fail);}
260 if(x1[2][2]==2){setverdict(pass);}
261 else{setverdict(fail);}
262 if(x1[2][3]==3){setverdict(pass);}
263 else{setverdict(fail);}
264 if(x2[0][2]==11){setverdict(pass);}
265 else{setverdict(fail);}
266 if(x2[0][3]==22){setverdict(pass);}
267 else{setverdict(fail);}
268 if(x2[1][2]==1){setverdict(pass);}
269 else{setverdict(fail);}
270}
271
272testcase arrayAssignElem() runs on arrayOper_mycomp{
273var integer x1[2], x2[2], x3[2], x4[5] ; //array of basic types
274x1:={ 3, 2 };
275x2:={ 1, 2 };
276x3:=x2;
277x2[0]:=3; //change element to value
278x3[0]:=x2[0]; //change element to element
279x4[2]:=2; // out of order
280if (x1[1]==2) {setverdict(pass);} //accessing individual element
281 else {setverdict(fail);}
282if (x2[0]==3) {setverdict(pass);} // change element to value
283 else {setverdict(fail);}
284if (x2[1]==2) {setverdict(pass);}
285 else {setverdict(fail);}
286if (x3[0]==3) {setverdict(pass);} // change element to element
287 else {setverdict(fail);}
288if (x3[1]==2) {setverdict(pass);}
289 else {setverdict(fail);}
290if (x4[2]==2) {setverdict(pass);} // out of order
291 else {setverdict(fail);}
292}
293
294testcase arrayAssignElemEnum() runs on arrayOper_mycomp{
295var arrayOper_myenum x1[2],x2[3]; //array of enumerated
296x1:={ xx1, xx2 };
297x1[0]:=xx3; //change element
298x2[2]:=xx3; // out of order
299if (x1[0]==xx3) {setverdict(pass);} // change element
300 else {setverdict(fail);}
301if (x1[1]==xx2) {setverdict(pass);}
302 else {setverdict(fail);}
303if (x2[2]==xx3) {setverdict(pass);} // out of order
304 else {setverdict(fail);}
305}
306
307testcase arrayAssignElemRec() runs on arrayOper_mycomp{
308var arrayOper_trecord x1[2],x2[2]; //array of record
309x1:={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
310x1[0].x1:=2;
311x1[1].x1:=3;
312x2[1]:= {x1:=2, x2:=1.3}; //out of order
313if (x1[0].x1==2) {setverdict(pass);} // change element
314 else {setverdict(fail);}
315if (x1[0].x2==1.2) {setverdict(pass);}
316 else {setverdict(fail);}
317if (x1[1].x1==3) {setverdict(pass);}
318 else {setverdict(fail);}
319if (x1[1].x2==3.4) {setverdict(pass);}
320 else {setverdict(fail);}
321if (x2[1].x1==2) {setverdict(pass);} // out of order
322 else {setverdict(fail);}
323if (x2[1].x2==1.3) {setverdict(pass);}
324 else {setverdict(fail);}
325}
326
327testcase arrayAssignElemRecof() runs on arrayOper_mycomp{
328var arrayOper_trecof x1[2],x2[3]; //record of record of
329x1:={ { '12AB'O, 'CD12'O }, { 'ABCD'O } };
330x1[0][1]:='34AB'O; //change element
331x2[2]:={'12CD'O}; //out of order
332if (x1[0][0]=='12AB'O) {setverdict(pass);} // change element
333 else {setverdict(fail);}
334if (x1[0][1]=='34AB'O) {setverdict(pass);}
335 else {setverdict(fail);}
336if (x1[1][0]=='ABCD'O) {setverdict(pass);}
337 else {setverdict(fail);}
338if (x2[2][0]=='12CD'O) {setverdict(pass);} //out of order
339 else {setverdict(fail);}}
340
341testcase arrayAssignElemSet() runs on arrayOper_mycomp{
342var arrayOper_tset x1[2],x2[3]; //array of set
343x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
344x1[0].x2:=3.4; //change element
345x2[2]:={ x1:=2, x2:=1.3 }; // out of order
346if (x1[0].x1==1) {setverdict(pass);} //change element
347 else {setverdict(fail);}
348if (x1[0].x2==3.4) {setverdict(pass);}
349 else {setverdict(fail);}
350if (x1[1].x1==2) {setverdict(pass);}
351 else {setverdict(fail);}
352if (not(ispresent(x1[1].x2))) {setverdict(pass);}
353 else {setverdict(fail);}
354if (x2[2].x1==2) {setverdict(pass);} //out of order
355 else {setverdict(fail);}
356if (x2[2].x2==1.3) {setverdict(pass);}
357 else {setverdict(fail);}
358}
359
360testcase arrayAssignElemSetof() runs on arrayOper_mycomp{
361var arrayOper_tsetof x1[2],x2[3]; //array of set of
362x1:={ { "1" }, {"a","7"}};
363x1[0][0]:="h"; // change element
364x2[2]:={"2"}; //out of order
365if (x1[0][0]=="h") {setverdict(pass);} //change element
366 else {setverdict(fail);}
367if (x1[1][0]=="a") {setverdict(pass);}
368 else {setverdict(fail);}
369if (x1[1][1]=="7") {setverdict(pass);}
370 else {setverdict(fail);}
371if (x2[2][0]=="2") {setverdict(pass);} // out of order
372 else {setverdict(fail);}
373}
374
375testcase arrayAssignElemUnion() runs on arrayOper_mycomp{
376//var arrayOper_tunion temp5 := {x2:=1.3}
377var arrayOper_tunion x1[2],x2[3]; //array of union
378x1:={ {x1 :=3 }, {x2:=1.3} };
379x1[0].x2:=3.4; //change element
380x2[2]:={ x2:=1.4}; // out of order
381if (x1[0].x2==3.4) {setverdict(pass);} //changed element
382 else {setverdict(fail);}
383if (ischosen(x1[0].x2)) {setverdict(pass);}
384 else {setverdict(fail);}
385if (not(ischosen(x1[0].x1))) {setverdict(pass);}
386 else {setverdict(fail);}
387if (x1[1].x2==1.3) {setverdict(pass);}
388 else {setverdict(fail);}
389if (ischosen(x1[1].x2)) {setverdict(pass);}
390 else {setverdict(fail);}
391if (not(ischosen(x1[1].x1))) {setverdict(pass);}
392 else {setverdict(fail);}
393if (x2[2].x2==1.4) {setverdict(pass);} //out of order
394 else {setverdict(fail);}
395if (ischosen(x2[2].x2)) {setverdict(pass);}
396 else {setverdict(fail);}
397if (not(ischosen(x2[2].x1))) {setverdict(pass);}
398 else {setverdict(fail);}
399}
400
401testcase arrayAssignSubArrayElem() runs on arrayOper_mycomp{
402 var integer x1[4][2]; //array of basic types
403 var integer x2[2][2];
404 var integer x3[1][2];
405 x1:={{1,2},{3,4},{5,6},{7,8}};
406 x2:={x1[0],x1[3]};
407 x3[0]:={x1[0][0],3};
408 if(x2[0][0]==1){setverdict(pass);}
409 else {setverdict(fail);}
410 if(x2[0][1]==2){setverdict(pass);}
411 else {setverdict(fail);}
412 if(x2[1][0]==7){setverdict(pass);}
413 else {setverdict(fail);}
414 if(x2[1][1]==8){setverdict(pass);}
415 else {setverdict(fail);}
416 if(x3[0][0]==1){setverdict(pass);}
417 else {setverdict(fail);}
418 if(x3[0][1]==3){setverdict(pass);}
419 else {setverdict(fail);}
420}
421
422testcase arrayAssignRangedArrayElem() runs on arrayOper_mycomp{
423 var integer x1[1..2][2..3];
424 var integer x2[0..1][2..3];
425 x1:={{1,2},{2,3}};
426 x2:={{11,22},x1[1]};
427 if(x1[1][2]==1){setverdict(pass);}
428 else{setverdict(fail);}
429 if(x1[1][3]==2){setverdict(pass);}
430 else{setverdict(fail);}
431 if(x1[2][2]==2){setverdict(pass);}
432 else{setverdict(fail);}
433 if(x1[2][3]==3){setverdict(pass);}
434 else{setverdict(fail);}
435 if(x2[0][2]==11){setverdict(pass);}
436 else{setverdict(fail);}
437 if(x2[0][3]==22){setverdict(pass);}
438 else{setverdict(fail);}
439 if(x2[1][2]==1){setverdict(pass);}
440 else{setverdict(fail);}
441}
442
443testcase arrayConst() runs on arrayOper_mycomp{
444const integer const1[3]:={1,2,3} //array of basic types
445if (arrayOper_const1[0]==1) {setverdict(pass);} //definition part
446 else {setverdict(fail);}
447if (arrayOper_const1[1]==2) {setverdict(pass);}
448 else {setverdict(fail);}
449if (const1[0]==1) {setverdict(pass);} //testcase
450 else {setverdict(fail);}
451if (const1[1]==2) {setverdict(pass);}
452 else {setverdict(fail);}
453if (const1[2]==3) {setverdict(pass);}
454 else {setverdict(fail);}
455}
456
457testcase arrayConstEnum() runs on arrayOper_mycomp{
458const arrayOper_myenum const1[3]:={xx1,xx2,xx3} //array of enumerated
459if (arrayOper_const2[0]==xx2) {setverdict(pass);} //definition part
460 else {setverdict(fail);}
461if (arrayOper_const2[1]==xx1) {setverdict(pass);}
462 else {setverdict(fail);}
463if (const1[0]==xx1) {setverdict(pass);} //testcase
464 else {setverdict(fail);}
465if (const1[1]==xx2) {setverdict(pass);}
466 else {setverdict(fail);}
467if (const1[2]==xx3) {setverdict(pass);}
468 else {setverdict(fail);}
469}
470
471testcase arrayConstRec() runs on arrayOper_mycomp{
472const arrayOper_trecord const4[2]:={ //array of record
473 { x1:=1, x2:=1.2 }, arrayOper_temp1 };
474if (arrayOper_const4[0].x1==1) {setverdict(pass);} //definition part
475 else {setverdict(fail);}
476if (arrayOper_const4[0].x2==1.2) {setverdict(pass);}
477 else {setverdict(fail);}
478if (arrayOper_const4[1]==arrayOper_temp1) {setverdict(pass);}
479 else {setverdict(fail);}
480if (const4[0].x1==1) {setverdict(pass);} //testcase
481 else {setverdict(fail);}
482if (const4[0].x2==1.2) {setverdict(pass);}
483 else {setverdict(fail);}
484if (const4[1]==arrayOper_temp1) {setverdict(pass);}
485 else {setverdict(fail);}
486}
487
488testcase arrayConstRecof() runs on arrayOper_mycomp{
489const arrayOper_trecof const6[2]:={ //array of record of
490 { '12AB'O, 'CD12'O }, arrayOper_temp2 };
491if (arrayOper_const6[0][0]=='12AB'O) {setverdict(pass);} //definition part
492 else {setverdict(fail);}
493if (arrayOper_const6[0][1]=='CD12'O) {setverdict(pass);}
494 else {setverdict(fail);}
495if (arrayOper_const6[1]==arrayOper_temp2) {setverdict(pass);}
496 else {setverdict(fail);}
497if (const6[0][0]=='12AB'O) {setverdict(pass);} //testcase
498 else {setverdict(fail);}
499if (const6[0][1]=='CD12'O) {setverdict(pass);}
500 else {setverdict(fail);}
501if (const6[1]==arrayOper_temp2) {setverdict(pass);}
502 else {setverdict(fail);}
503}
504
505testcase arrayConstSet() runs on arrayOper_mycomp{
506const arrayOper_tset const8[2]:={ //array of set
507 { x1:=2, x2:=1.3}, arrayOper_temp3 };
508if (arrayOper_const8[0].x1==2) {setverdict(pass);} //definition part
509 else {setverdict(fail);}
510if (arrayOper_const8[0].x2==1.3) {setverdict(pass);}
511 else {setverdict(fail);}
512if (arrayOper_const8[1]==arrayOper_temp3) {setverdict(pass);}
513 else {setverdict(fail);}
514if (const8[0].x1==2) {setverdict(pass);} //testcase
515 else {setverdict(fail);}
516if (const8[0].x2==1.3) {setverdict(pass);}
517 else {setverdict(fail);}
518if (const8[1]==arrayOper_temp3) {setverdict(pass);}
519 else {setverdict(fail);}
520}
521
522testcase arrayConstSetof() runs on arrayOper_mycomp{
523const arrayOper_tsetof const10[2]:={ //array of set of
524 {"a","b"}, {"f","8"} };
525if (arrayOper_const10[0][0]=="a") {setverdict(pass);} //definition part
526 else {setverdict(fail);}
527if (arrayOper_const10[0][1]=="b") {setverdict(pass);}
528 else {setverdict(fail);}
529if (arrayOper_const10[1]==arrayOper_temp4) {setverdict(pass);}
530 else {setverdict(fail);}
531if (const10[0][0]=="a") {setverdict(pass);} //testcase
532 else {setverdict(fail);}
533if (const10[0][1]=="b") {setverdict(pass);}
534 else {setverdict(fail);}
535if (const10[1][0]=="f") {setverdict(pass);}
536 else {setverdict(fail);}
537if (const10[1][1]=="8") {setverdict(pass);}
538 else {setverdict(fail);}
539}
540
541testcase arrayConstUnion() runs on arrayOper_mycomp{
542const arrayOper_tunion const12[2]:={ //array of union
543 { x1 :=3 }, { x2:=1.3 } };
544if (arrayOper_const12[0].x1==3) {setverdict(pass);} //definition part
545 else {setverdict(fail);}
546if (ischosen(arrayOper_const12[0].x1)) {setverdict(pass);}
547 else {setverdict(fail);}
548if (not(ischosen(arrayOper_const12[0].x2))) {setverdict(pass);}
549 else {setverdict(fail);}
550if (arrayOper_const12[1]==arrayOper_temp5) {setverdict(pass);}
551 else {setverdict(fail);}
552if (const12[0].x1==3) {setverdict(pass);} //testcase
553 else {setverdict(fail);}
554if (ischosen(const12[0].x1)) {setverdict(pass);}
555 else {setverdict(fail);}
556if (not(ischosen(const12[0].x2))) {setverdict(pass);}
557 else {setverdict(fail);}
558if (const12[1].x2==1.3) {setverdict(pass);}
559 else {setverdict(fail);}
560if (ischosen(const12[1].x2)) {setverdict(pass);}
561 else {setverdict(fail);}
562if (not(ischosen(const12[1].x1))) {setverdict(pass);}
563 else {setverdict(fail);}
564}
565
566testcase arrayComp() runs on arrayOper_mycomp{
567var integer x1[3],x2[0..2],x3[3],x4[3],x5[4]; //array of basic type
568x1:={ 1,2,3 };
569x2:={ 1,2,3 };
570x3:={ 1,2,4 };
571x4:={3,2,1};
572x5:={1,2,3,-};
573if (x1==x2) {setverdict(pass);}
574 else {setverdict(fail);}
575if (not(x1==x3)) {setverdict(pass);}
576 else {setverdict(fail);}
577if (not(x1==x4)) {setverdict(pass);} //out of order
578 else {setverdict(fail);}
579if (x1!=x3) {setverdict(pass);}
580 else {setverdict(fail);}
581if (not(x1!=x2)) {setverdict(pass);}
582 else {setverdict(fail);}
583if (x1!=x4) {setverdict(pass);} //out of order
584 else {setverdict(fail);}
585}
586
587testcase arrayCompConst() runs on arrayOper_mycomp{ //In testcase definition//
588 const integer c_array1[4] := { 1,2,3,4};
589 const integer c_array2[4] := { 1,2,3,4};
590 const integer c_array3[4] := { 4,3,2,1};
591 const integer c_array4_ind[4] := { [0] := 1, [1] := 2, [2] := 3, [3] := 4};
592 const integer c_array5_ind[4] := { [3] := 4, [1] := 2, [2] := 3, [0] := 1};
593
594
595 var integer vl_array5[4] := { 1,2,3,4};
596
597
598 if(c_array1 == c_array1) {setverdict(pass);}
599 else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
600
601 if({1,2,3,4} == c_array1) {setverdict(pass);}
602 else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
603
604 if(c_array1 == c_array2) {setverdict(pass);}
605 else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
606
607 if(c_array1 == c_array4_ind) {setverdict(pass);}
608 else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
609
610 if(c_array4_ind == c_array4_ind) {setverdict(pass);}
611 else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
612
613 if({ [0] := 1, [1] := 2, [2] := 3, [3] := 4} == c_array4_ind) {setverdict(pass);}
614 else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
615
616 if(c_array4_ind == c_array5_ind) {setverdict(pass);}
617 else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
618
619
620 if(vl_array5 == c_array1) {setverdict(pass);}
621 else {setverdict(fail);}
622}
623
624testcase arrayCompEnum() runs on arrayOper_mycomp{
625var arrayOper_myenum x1[3],x2[3],x3[3]; // array of enum
626x1:={ xx1,xx2,xx3 };
627x2:={ xx1,xx2,xx3 };
628x3:={ xx1,xx2,xx2 };
629if (x1==x2) {setverdict(pass);}
630 else {setverdict(fail);}
631if (not(x1==x3)) {setverdict(pass);}
632 else {setverdict(fail);}
633if (x1!=x3) {setverdict(pass);}
634 else {setverdict(fail);}
635if (not(x1!=x2)) {setverdict(pass);}
636 else {setverdict(fail);}
637}
638
639testcase arrayCompRec() runs on arrayOper_mycomp{
640var arrayOper_trecord x1[2],x2[2],x3[2]; // array of record
641x1 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
642x2 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
643x3 :={ { x1:=2, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
644if (x1==x2) {setverdict(pass);}
645 else {setverdict(fail);}
646if (not(x1==x3)) {setverdict(pass);}
647 else {setverdict(fail);}
648if (x1!=x3) {setverdict(pass);}
649 else {setverdict(fail);}
650if (not(x1!=x2)) {setverdict(pass);}
651 else {setverdict(fail);}
652}
653
654
655testcase arrayCompRecof() runs on arrayOper_mycomp{
656//var arrayOper_trecof temp2:={'AF12'O};
657var arrayOper_trecof x1[2],x2[2],x3[2]; //array of record of
658x1:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
659x2:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
660x3:={ { '12AB'O }, {'AF12'O} };
661if (x1==x2) {setverdict(pass);}
662 else {setverdict(fail);}
663if (not(x1==x3)) {setverdict(pass);}
664 else {setverdict(fail);}
665if (x2!=x3) {setverdict(pass);}
666 else {setverdict(fail);}
667if (not(x1!=x2)) {setverdict(pass);}
668 else {setverdict(fail);}
669}
670
671
672testcase arrayCompSet() runs on arrayOper_mycomp{
673//var arrayOper_tset temp1:={ x1:=2, x2:=omit };
674var arrayOper_tset x1[2],x2[2],x3[2]; //array of set
675x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit } };
676x2:={ { x2:=1.2, x1:=1 }, { x1:=2, x2:=omit }};
677x3:={ { x1:=1, x2:=1.2 }, { x1:=1, x2:=1.2 } };
678if (x1==x2) {setverdict(pass);}
679 else {setverdict(fail);}
680if (not(x2==x3)) {setverdict(pass);}
681 else {setverdict(fail);}
682if (x1!=x3) {setverdict(pass);}
683 else {setverdict(fail);}
684if (not(x1!=x2)) {setverdict(pass);}
685 else {setverdict(fail);}
686}
687
688testcase arrayCompSetof() runs on arrayOper_mycomp{
689var arrayOper_tsetof temp2:={"a","7"};
690var arrayOper_tsetof x1[2],x2[2],x3[2]; //array of set of
691x1:={ { "1", "a" }, temp2 };
692x2:={ { "1", "a" }, {"a","7"} };
693x3:={ { "1", "a" }, {"l", "k"} };
694if (x1==x2) {setverdict(pass);}
695 else {setverdict(fail);}
696if (not(x2==x3)) {setverdict(pass);}
697 else {setverdict(fail);}
698if (x1!=x3) {setverdict(pass);}
699 else {setverdict(fail);}
700if (not(x1!=x2)) {setverdict(pass);}
701 else {setverdict(fail);}
702}
703
704testcase arrayCompUnion() runs on arrayOper_mycomp{
705var arrayOper_tunion temp5 := {x2:=1.3}
706var arrayOper_tunion x1[2],x2[2],x3[2]; //array of union
707x1:={ { x1 :=3 }, { x2:=1.3 } };
708x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
709x3:={ { x2 :=3.9 },temp5 }; //{ x2:=1.3 }
710if (x1==x2) {setverdict(pass);}
711 else {setverdict(fail);}
712if (not(x1==x3)) {setverdict(pass);}
713 else {setverdict(fail);}
714if (x2!=x3) {setverdict(pass);}
715 else {setverdict(fail);}
716if (not(x1!=x2)) {setverdict(pass);}
717 else {setverdict(fail);}
718}
719
720testcase arrayMatching() runs on arrayOper_mycomp{
721 template arrayOper_triplet template1:={{1,2},{2,3},{3,4}};
722 template arrayOper_triplet template2:=
723 {subset(1,2,3),subset(3,4,5),subset(5,6,7,8)};
724 template arrayOper_triplet template3:={superset(1),superset(2),superset(4)};
725 template arrayOper_trecord2 template4:={{1,?,3}};
726 var arrayOper_trecord2 x1:={{1,2,3}};
727 if(match(arrayOper_const13[0],template1)){setverdict(pass);}
728 else {setverdict(fail);}
729 if(not(match(arrayOper_const13[0],template2))){setverdict(pass);}
730 else {setverdict(fail);}
731 if(match(arrayOper_const13[1],template2)){setverdict(pass);}
732 else {setverdict(fail);}
733 if(not(match(arrayOper_const13[1],template3))){setverdict(pass);}
734 else {setverdict(fail);}
735 if(match(arrayOper_const13[2],template3)){setverdict(pass);}
736 else {setverdict(fail);}
737 if(match(x1,template4)){setverdict(pass);}
738 else{setverdict(fail);}
739}
740
741testcase arraySummation() runs on arrayOper_mycomp{
742 var integer x1[2][3]:={{1,2,3},{4,5,6}};
743 var integer i1,i2,sum;
744 x1[1][1]:=3;
745 sum:=0;
746 for(i1:=0;i1<sizeof(x1);i1:=i1+1)
747 {
748 for(i2:=0;i2<sizeof(x1[i1]);i2:=i2+1)
749 {
750 sum:=sum+x1[i1][i2];
751 }
752 }
753 if(sum==19){setverdict(pass);}
754 else{setverdict(fail);}
755}
756
757testcase arrayRotateOperators() runs on arrayOper_mycomp{
758 var integer x1[5]:={1,2,3,4,5}
759 var integer x2[5],x3[5],x4[5],x5[5],x6[5],x7[5];
760 x2 := x1 <@ 1;
761 x3 := x1 <@ 10;
762 x4 := x1 <@ 3 <@ 2;
763 x5 := x1 @> 1;
764 x6 := x1 @> 10;
765 x7 := x1 @> 3 @> 2;
766 if (x2 == {2,3,4,5,1}) {setverdict(pass);}
767 else {setverdict(fail);}
768 if (x3 == x1) {setverdict(pass);}
769 else {setverdict(fail);}
770 if (x4 == x1) {setverdict(pass);}
771 else {setverdict(fail);}
772 if (x5 == {5,1,2,3,4}) {setverdict(pass);}
773 else {setverdict(fail);}
774 if (x6 == x1) {setverdict(pass);}
775 else {setverdict(fail);}
776 if (x7 == x1) {setverdict(pass);}
777 else {setverdict(fail);}
778}
779
780testcase arrayLengthof() runs on arrayOper_mycomp{
781// lengthof returns the sequential number of the last initialized element of the array
782 var integer x1[2]:={1,2} // last init element is the second
783 var integer x2[2],x3[3],x4[2],x5[5]; // array of basic types
784 x2:={ 1, 2 }; // last init element is the second
785 x3:={1,2, -}; // last init element is the second
786 // x4: last init element is the zero
787 x5[2]:=1; // last init element is the third
788 if (lengthof(x1)==2) {setverdict(pass);} //assignment at declaration
789 else {setverdict(fail);}
790 if (lengthof(x2)==2) {setverdict(pass);} //assignment later
791 else {setverdict(fail);}
792 if (lengthof(x3)==2) {setverdict(pass);} //partly filled, TITAN specific
793 else {setverdict(fail);}
794 if (lengthof(x4)==0) {setverdict(pass);} //empty
795 else {setverdict(fail);}
796 if (lengthof(x5)==3) {setverdict(pass);} //out of order
797 else {setverdict(fail);}
798}
799
800testcase arraySizeof() runs on arrayOper_mycomp{
801 var integer x1[2]:={1,2}
802 var integer x2[2],x3[3],x4[2],x5[5]; //array of basic types
803 x2:={ 1, 2 };
804 x3:={1,2, -}; // partly filled array
805 x5[2]:=1; //out of order
806 if (sizeof(x1)==2) {setverdict(pass);} //assignment at declaration
807 else {setverdict(fail);}
808 if (sizeof(x2)==2) {setverdict(pass);} //assignment later
809 else {setverdict(fail);}
810 if (sizeof(x3)==3) {setverdict(pass);} //partly filled, TITAN specific
811 else {setverdict(fail);}
812 if (sizeof(x4)==2) {setverdict(pass);} //empty
813 else {setverdict(fail);}
814 if (sizeof(x5)==5) {setverdict(pass);} //out of order
815 else {setverdict(fail);}
816}
817
818testcase arraySizeof2() runs on arrayOper_mycomp{
819 var integer x1[1..3][1]:={{1},{2},{3}};
820 var integer x2[11..12],x3[3..5],x4[-8..-7],x5[-4..0]; //array of basic types
821 x2:={ 1, 2 };
822 x3:={1,2, -}; // partly filled array
823 x5[-3]:=1; //out of order
824 if (sizeof(x1)==3) {setverdict(pass);} //assignment at declaration
825 else {setverdict(fail);}
826 if (sizeof(x1[1])==1) {setverdict(pass);}
827 else {setverdict(fail);}
828 if (sizeof(x2)==2) {setverdict(pass);} //assignment later
829 else {setverdict(fail);}
830 if (sizeof(x3)==3) {setverdict(pass);} //partly filled, TITAN specific
831 else {setverdict(fail);}
832 if (sizeof(x4)==2) {setverdict(pass);} //empty
833 else {setverdict(fail);}
834 if (sizeof(x5)==5) {setverdict(pass);} //out of order
835 else {setverdict(fail);}
836}
837
838testcase arrayIsvalue() runs on arrayOper_mycomp{
839 var integer x0[2];
840 var integer x1[2] := { 12,34 }
841 var integer x2[2];
842 x2:={ 32, 12 };
843 var integer x3[2 .. 4];
844 var integer x4[2 .. 4] := {32,12,3};
845 var template integer x5[3] := omit;
846 var template integer x6[3] := { 1, 2, 3 } ifpresent;
847
848 if ( isvalue(x0) ) { setverdict(fail); } else { setverdict(pass); };
849 if ( isvalue(x0[0]) ) { setverdict(fail); } else { setverdict(pass); };
850 if ( isvalue(x1) ) { setverdict(pass); } else { setverdict(fail); };
851 if ( isvalue(x2) ) { setverdict(pass); } else { setverdict(fail); };
852 if ( isvalue(x3) ) { setverdict(fail); } else { setverdict(pass); };
853 if ( isvalue(x4) ) { setverdict(pass); } else { setverdict(fail); };
854 if ( isvalue(x5) ) { setverdict(fail); } else { setverdict(pass); };
855 if ( isvalue(x6) ) { setverdict(fail); } else { setverdict(pass); };
856}
857
858testcase emptyTemplateArrayOneDimensional() runs on arrayOper_mycomp{
859 var template charstring csa[10]
860 var template charstring cs
861 //cs := csa[0]
862 if ( isbound(csa[0]) ) { setverdict(fail); } else { setverdict(pass); };
863}
864
865testcase emptyTemplateArrayTwoDimensional() runs on arrayOper_mycomp{
866 var template charstring csa[10][10]
867 var template charstring cs
868 //cs := csa[0][1]
869 if ( isbound(csa[0][1]) ) { setverdict(fail); } else { setverdict(pass); };
870}
871
872type enumerated DefaultCallHandling {
873 releaseCall, continueCall
874};
875type record DP_AnalysedInfoCriterium {};
876type record of DP_AnalysedInfoCriterium DP_AnalysedInfoCriteriumList;
877template DP_AnalysedInfoCriterium t_MAP_DP_AnalysedInfoCriterium(octetstring ox,
878 integer ix, charstring cx, DefaultCallHandling dx) := {}
879function f_Converter_Charstring_To_Map(in charstring c) return octetstring {
880 return char2oct(c);
881}
882template DP_AnalysedInfoCriterium t_MAP_D_CSI(template DP_AnalysedInfoCriteriumList tdpl, integer num) := { }
883
884testcase TemplateArray() runs on arrayOper_mycomp{
885
886 var template DP_AnalysedInfoCriterium v_DP_AnalysedInfoCriterium[8];
887 var charstring v_gsmSCF := "howdy";
888 var template DP_AnalysedInfoCriterium v_D_CSI_1 ;
889 v_DP_AnalysedInfoCriterium[0] := t_MAP_DP_AnalysedInfoCriterium( '91'O& f_Converter_Charstring_To_Map( "491799000000003"), // ISDN-AddressString,
890 50000, // ServiceKey,
891 v_gsmSCF,// ISDN-AddressString,
892 releaseCall); // DefaultCallHandling,
893 v_DP_AnalysedInfoCriterium[1] := t_MAP_DP_AnalysedInfoCriterium( '91'O& f_Converter_Charstring_To_Map( "491799000000002"), // ISDN-AddressString,
894 32768, // ServiceKey,
895 v_gsmSCF,// ISDN-AddressString,
896 releaseCall); // DefaultCallHandling,
897
898 v_DP_AnalysedInfoCriterium[2] := t_MAP_DP_AnalysedInfoCriterium( 'A1'O&f_Converter_Charstring_To_Map( "491799000000001"), // ISDN-AddressString,
899 128, // ServiceKey,
900 v_gsmSCF,// ISDN-AddressString,
901 continueCall); // DefaultCallHandling,
902
903 v_D_CSI_1 := t_MAP_D_CSI ({v_DP_AnalysedInfoCriterium[0], v_DP_AnalysedInfoCriterium[1], v_DP_AnalysedInfoCriterium[2 ]},//DP-AnalysedInfoCriteriaList
904 3); //CamelCapabilityHandling
905
906 if ( isbound(t_MAP_D_CSI({v_DP_AnalysedInfoCriterium[0], v_DP_AnalysedInfoCriterium[1], v_DP_AnalysedInfoCriterium[2 ]},3)) )
907 { setverdict(pass); } else { setverdict(fail); };
908}
909
910control
911{
912 const arrayOper_tsetof2 cl_1[3][3]:={ // constant in control part
913 {{1,2},{2,3},{3,4}},{{1,2},{4,5},{6,7}},{{2,1},{3,2},{4,3}}};
914 var arrayOper_tsetof2 vl_1[3][3]; //variable in control part
915
916 execute(arrayAssign());
917 execute(arrayAssignEnum());
918 execute(arrayAssignRec());
919 execute(arrayAssignRecof());
920 execute(arrayAssignSet());
921 execute(arrayAssignSetof());
922 execute(arrayAssignUnion());
923 execute(arrayAssignArray());
924 execute(arrayAssignSubArray());
925 execute(arrayAssignRangedArray());
926 execute(arrayAssignElem());
927 execute(arrayAssignElemEnum());
928 execute(arrayAssignElemRec());
929 execute(arrayAssignElemRecof());
930 execute(arrayAssignElemSet());
931 execute(arrayAssignElemSetof());
932 execute(arrayAssignElemUnion());
933 execute(arrayAssignSubArrayElem());
934 execute(arrayAssignRangedArrayElem());
935 execute(arrayConst());
936 execute(arrayConstEnum());
937 execute(arrayConstRec());
938 execute(arrayConstRecof());
939 execute(arrayConstSet());
940 execute(arrayConstSetof());
941 execute(arrayConstUnion());
942 execute(arrayComp());
943 execute(arrayCompConst());
944 execute(arrayCompEnum());
945 execute(arrayCompRec());
946 execute(arrayCompRecof());
947 execute(arrayCompSet());
948 execute(arrayCompSetof());
949 execute(arrayCompUnion());
950 execute(arrayMatching());
951 execute(arraySummation());
952
953 execute(arrayRotateOperators());
954 execute(arrayLengthof());
955 execute(arraySizeof());
956 execute(arraySizeof2());
957 execute(arrayIsvalue());
958
959 execute(emptyTemplateArrayOneDimensional());
960 execute(emptyTemplateArrayTwoDimensional());
961 execute(TemplateArray());
962}
963
964}
Titan Core - Deliverables
This page took 0.059361 seconds and 5 git commands to generate.