projects / deliverable / titan.core.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Sync with 5.4.0
[deliverable/titan.core.git] / regression_test / recofOper / TrecofOper.ttcn
CommitLineData
970ed795 1/******************************************************************************
3abe9331 2 * Copyright (c) 2000-2015 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
7 ******************************************************************************/
8module TrecofOper {
9// ********** Type definitions *********************
10type component recofOper_mycomp {};
11type enumerated recofOper_myenum {xx1,xx2,xx3};
12type record recofOper_trecord {
13 integer x1 optional,
14 float x2 };
15type record of octetstring recofOper_trecof;
16type set recofOper_tset {
17 integer x1,
18 float x2 optional };
19type set of charstring recofOper_tsetof;
20type union recofOper_tunion {
21 integer x1,
22 float x2 };
23type record of integer recofOper_myrecof1; // record of basic types
24type record of recofOper_myenum recofOper_myrecof2; // record of enum
25type record of recofOper_trecord recofOper_myrecof3; // record of record
26type record of recofOper_trecof recofOper_myrecof4; // record of record of
27type record of recofOper_tset recofOper_myrecof5; // record of set
28type record of recofOper_tsetof recofOper_myrecof6; // record of set of
29type record of recofOper_tunion recofOper_myrecof7; // record of union
30type record length (3)
31 of record length (3)
32 of record length (3) of integer threeD;
33// *************** Constanst ***********************
34const recofOper_trecord recofOper_temp1:={ x1:=omit, x2:=3.4 };
35const recofOper_trecof recofOper_temp2:={ 'AF12'O };
36const recofOper_tset recofOper_temp3:={ x1:=234, x2:=1.9};
37const recofOper_tsetof recofOper_temp4:={"f","8"};
38const recofOper_tunion recofOper_temp5:={ x2:=1.3 };
39const recofOper_myrecof1 recofOper_const1:={ 1,2 } //record of basic types
40const recofOper_myrecof2 recofOper_const2:={ xx2, xx1 }
41const recofOper_myrecof3 recofOper_const4:={ //record of record
42 { x1:=1, x2:=1.2 },recofOper_temp1 };
43const recofOper_myrecof4 recofOper_const6:={ //record of record of
44 { '12AB'O, 'CD12'O }, recofOper_temp2 };
45const recofOper_myrecof5 recofOper_const8:={ //record of set
46 { x1:=2, x2:=1.3}, recofOper_temp3 };
47const recofOper_myrecof6 recofOper_const10:={ //record of set of
48 {"a","b"}, recofOper_temp4 }; //{"f","8"},
49const recofOper_myrecof7 recofOper_const12:={ //record of union
50 { x1 :=3 }, recofOper_temp5 }; //{ x2:=1.3 }
51
52testcase recofAssign() runs on recofOper_mycomp{
53var recofOper_myrecof1 x1:={ 12,34} //record of basic types
54var recofOper_myrecof1 x2,x3,x4;
55x2:={ 32, 12 };
56x3:={12};
57x3:={23,21};
58x4:={};
59if (x1[0]==12) {setverdict(pass);} //at declaration
60 else {setverdict(fail);}
61if (x1[1]==34) {setverdict(pass);}
62 else {setverdict(fail);}
63if (x2[0]==32) {setverdict(pass);} //later
64 else {setverdict(fail);}
65if (x2[1]==12) {setverdict(pass);}
66 else {setverdict(fail);}
67if (x3[0]==23) {setverdict(pass);} //later, change size
68 else {setverdict(fail);}
69if (x3[1]==21) {setverdict(pass);}
70 else {setverdict(fail);}
71//if (x4=={}) {setverdict(pass);} //empty record of
72// else {setverdict(fail);}
73}
74
75testcase recofReAssign() runs on recofOper_mycomp
76{
77 var recofOper_myrecof1 x := { 1, 2, 3, 4 };
78 // assigning a new value that is shorter than the previous
79 x := { -, 5, - };
80 if (sizeof(x) == 3) { setverdict(pass); }
81 else { setverdict(fail); }
82 if (x[0] == 1) { setverdict(pass); }
83 else { setverdict(fail); }
84 if (x[1] == 5) { setverdict(pass); }
85 else { setverdict(fail); }
86 if (x[2] == 3) { setverdict(pass); }
87 else { setverdict(fail); }
88 x := { 6 };
89 if (sizeof(x) == 1) { setverdict(pass); }
90 else { setverdict(fail); }
91 if (x[0] == 6) { setverdict(pass); }
92 x := { };
93 if (sizeof(x) == 0) { setverdict(pass); }
94 else { setverdict(fail); }
95}
96
97testcase recofAssignEnum() runs on recofOper_mycomp{
98var recofOper_myrecof2 x1:={ xx2 } //record of enum
99var recofOper_myrecof2 x2;
100x2:={xx2,xx1};
101//at declaration
102if (x1[0]==xx2) {setverdict(pass);}
103 else {setverdict(fail);}
104//later
105if (x2[0]==xx2) {setverdict(pass);}
106 else {setverdict(fail);}
107if (x2[1]==xx1) {setverdict(pass);}
108 else {setverdict(fail);}
109}
110
111testcase recofAssignRec() runs on recofOper_mycomp{
112var recofOper_trecord temp1:={ x1:=omit, x2:=3.4 };
113var recofOper_myrecof3 x1:={ //record of record
114 { x1:=1, x2:=1.2 }, temp1 };
115var recofOper_myrecof3 x2;
116x2:={ { x1:=1, x2:=1.2 }, temp1 };
117if (x1[0].x1==1) {setverdict(pass);} //at declaration
118 else {setverdict(fail);}
119if (x1[0].x2==1.2) {setverdict(pass);}
120 else {setverdict(fail);}
121if (x1[1]==temp1) {setverdict(pass);}
122 else {setverdict(fail);}
123if (x2[0].x1==1) {setverdict(pass);} //later
124 else {setverdict(fail);}
125if (x2[0].x2==1.2) {setverdict(pass);}
126 else {setverdict(fail);}
127if (not(ispresent(x2[1].x1))) {setverdict(pass);}
128 else {setverdict(fail);}
129if (x2[1].x2==3.4) {setverdict(pass);}
130 else {setverdict(fail);}
131}
132
133testcase recofAssignRecof() runs on recofOper_mycomp{
134var recofOper_trecof temp2:={'AF12'O};
135var recofOper_myrecof4 x1:={ //record of record of
136 { '12AB'O, 'CD12'O }, temp2 };
137var recofOper_myrecof4 x2;
138x2:={ { '12AB'O, 'CD12'O }, temp2 };
139if (x1[0][0]=='12AB'O) {setverdict(pass);} //at declaration
140 else {setverdict(fail);}
141if (x1[0][1]=='CD12'O) {setverdict(pass);}
142 else {setverdict(fail);}
143if (x1[1]==temp2) {setverdict(pass);}
144 else {setverdict(fail);}
145if (x2[0][0]=='12AB'O) {setverdict(pass);} //later
146 else {setverdict(fail);}
147if (x2[0][1]=='CD12'O) {setverdict(pass);}
148 else {setverdict(fail);}
149if (x2[1][0]=='AF12'O) {setverdict(pass);}
150 else {setverdict(fail);}
151}
152
153testcase recofAssignSet() runs on recofOper_mycomp{
154var recofOper_tset temp1:={ x1:=2, x2:=omit };
155var recofOper_myrecof5 x1:={ //record of set
156 { x1:=1, x2:=1.2 }, temp1 };
157var recofOper_myrecof5 x2;
158x2:={ { x1:=1, x2:=1.2 }, temp1 };
159if (x1[0].x1==1) {setverdict(pass);} //at declaration
160 else {setverdict(fail);}
161if (x1[0].x2==1.2) {setverdict(pass);}
162 else {setverdict(fail);}
163if (x1[1]==temp1) {setverdict(pass);}
164 else {setverdict(fail);}
165if (x2[0].x1==1) {setverdict(pass);} //later
166 else {setverdict(fail);}
167if (x2[0].x2==1.2) {setverdict(pass);}
168 else {setverdict(fail);}
169if (x2[1].x1==2) {setverdict(pass);}
170 else {setverdict(fail);}
171if (not(ispresent(x2[1].x2))) {setverdict(pass);}
172 else {setverdict(fail);}
173}
174
175testcase recofAssignSetof() runs on recofOper_mycomp{
176var recofOper_tsetof temp2:={"a","7"};
177var recofOper_myrecof6 x1:={ //record of set of
178 { "1", "a" }, temp2 };
179var recofOper_myrecof6 x2;
180x2:={ { "1", "a" }, temp2 };
181if (x1[0][0]=="1") {setverdict(pass);} //at declaration
182 else {setverdict(fail);}
183if (x1[0][1]=="a") {setverdict(pass);}
184 else {setverdict(fail);}
185if (x1[1]==temp2) {setverdict(pass);}
186 else {setverdict(fail);}
187if (x2[0][0]=="1") {setverdict(pass);} //later
188 else {setverdict(fail);}
189if (x2[0][1]=="a") {setverdict(pass);}
190 else {setverdict(fail);}
191if (x2[1][0]=="a") {setverdict(pass);}
192 else {setverdict(fail);}
193if (x2[1][1]=="7") {setverdict(pass);}
194 else {setverdict(fail);}
195}
196
197testcase recofAssignUnion() runs on recofOper_mycomp{
198var recofOper_tunion temp5 := {x2:=1.3}
199var recofOper_myrecof7 x1:={ //record of union
200 { x1 :=3 }, temp5 }; //{ x2:=1.3
201var recofOper_myrecof7 x2;
202x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
203if (x1[0].x1==3) {setverdict(pass);} //at declaration
204 else {setverdict(fail);}
205if (ischosen(x1[0].x1)) {setverdict(pass);}
206 else {setverdict(fail);}
207if (not(ischosen(x1[0].x2))) {setverdict(pass);}
208 else {setverdict(fail);}
209if (x1[1]==temp5) {setverdict(pass);}
210 else {setverdict(fail);}
211if (x2[0].x1==3) {setverdict(pass);} //later
212 else {setverdict(fail);}
213if (ischosen(x2[0].x1)) {setverdict(pass);}
214 else {setverdict(fail);}
215if (not(ischosen(x2[0].x2))) {setverdict(pass);}
216 else {setverdict(fail);}
217if (x2[1].x2==1.3) {setverdict(pass);}
218 else {setverdict(fail);}
219if (ischosen(x2[1].x2)) {setverdict(pass);}
220 else {setverdict(fail);}
221if (not(ischosen(x2[1].x1))) {setverdict(pass);}
222 else {setverdict(fail);}
223}
224
225testcase recofAssignElem() runs on recofOper_mycomp{
226var recofOper_myrecof1 x1,x2,x3,x4,x5; //record of basic types
227x1:={ 3, 2 };
228x2:={ 1, 2 };
229x3:=x2;
230x4:=x2;
231x5:={2};
232x2[0]:=3; //change element to value
233x3[0]:=x1[0]; //change element to element
234x4[2]:=2; // add element
235x5[2]:=3; // out of order
236if (x1[1]==2) {setverdict(pass);} //accessing individual element
237 else {setverdict(fail);}
238if (x2[0]==3) {setverdict(pass);} // change element to value
239 else {setverdict(fail);}
240if (x2[1]==2) {setverdict(pass);}
241 else {setverdict(fail);}
242if (x3[0]==3) {setverdict(pass);} // change element to element
243 else {setverdict(fail);}
244if (x3[1]==2) {setverdict(pass);}
245 else {setverdict(fail);}
246if (x4[0]==1) {setverdict(pass);} // add element
247 else {setverdict(fail);}
248if (x4[1]==2) {setverdict(pass);}
249 else {setverdict(fail);}
250if (x4[2]==2) {setverdict(pass);}
251 else {setverdict(fail);}
252if (x5[2]==3) {setverdict(pass);} // out of order
253 else {setverdict(fail);}
254}
255
256testcase recofAssignElemEnum() runs on recofOper_mycomp{
257var recofOper_myrecof2 x1, x2,x3; //record of enumerated
258x1:={ xx1, xx2 };
259x2:={xx1, xx2};
260x3:={};
261x1[0]:=xx3; //change element
262x2[2]:=xx3; // add element
263x3[2]:=xx3; // out of order
264if (x1[0]==xx3) {setverdict(pass);} // change element
265 else {setverdict(fail);}
266if (x1[1]==xx2) {setverdict(pass);}
267 else {setverdict(fail);}
268if (x2[0]==xx1) {setverdict(pass);} // add element
269 else {setverdict(fail);}
270if (x2[1]==xx2) {setverdict(pass);}
271 else {setverdict(fail);}
272if (x2[2]==xx3) {setverdict(pass);}
273 else {setverdict(fail);}
274if (x3[2]==xx3) {setverdict(pass);} // out of order
275 else {setverdict(fail);}
276}
277
278testcase recofAssignElemRec() runs on recofOper_mycomp{
279//var recofOper_trecord temp1:={ x1:=omit, x2:=3.4 };
280var recofOper_myrecof3 x1,x2,x3; //record of record
281x1:={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
282x2:=x1;
283x1[0].x1:=2;
284//temp1.x1:=3;
285x1[1].x1:=3;
286x2[2]:= {x1:=2, x2:=1.3}; // add element
287x3[1]:= {x1:=2, x2:=1.3}; //out of order
288if (x1[0].x1==2) {setverdict(pass);} // change element
289 else {setverdict(fail);}
290if (x1[0].x2==1.2) {setverdict(pass);}
291 else {setverdict(fail);}
292if (x1[1].x1==3) {setverdict(pass);}
293 else {setverdict(fail);}
294if (x1[1].x2==3.4) {setverdict(pass);}
295 else {setverdict(fail);}
296if (x2[0].x1==1) {setverdict(pass);} //add element
297 else {setverdict(fail);}
298if (x2[0].x2==1.2) {setverdict(pass);}
299 else {setverdict(fail);}
300if (not(ispresent(x2[1].x1))) {setverdict(pass);}
301 else {setverdict(fail);}
302if (x2[1].x2==3.4) {setverdict(pass);}
303 else {setverdict(fail);}
304if (x2[2].x1==2) {setverdict(pass);}
305 else {setverdict(fail);}
306if (x2[2].x2==1.3) {setverdict(pass);}
307 else {setverdict(fail);}
308if (x3[1].x1==2) {setverdict(pass);} // out of order
309 else {setverdict(fail);}
310if (x3[1].x2==1.3) {setverdict(pass);}
311 else {setverdict(fail);}
312}
313
314
315testcase recofAssignElemRecof() runs on recofOper_mycomp{
316var recofOper_myrecof4 x1,x2,x3; //record of record of
317x1:={ { '12AB'O, 'CD12'O }, { 'ABCD'O } };
318x2:=x1;
319x1[0][1]:='34AB'O; //change element
320x2[2]:={ '1234'O}; //add element
321x3[2]:={'12CD'O}; //out of order
322if (x1[0][0]=='12AB'O) {setverdict(pass);} // change element
323 else {setverdict(fail);}
324if (x1[0][1]=='34AB'O) {setverdict(pass);}
325 else {setverdict(fail);}
326if (x1[1][0]=='ABCD'O) {setverdict(pass);}
327 else {setverdict(fail);}
328if (x2[0][0]=='12AB'O) {setverdict(pass);} // add element
329 else {setverdict(fail);}
330if (x2[0][1]=='CD12'O) {setverdict(pass);}
331 else {setverdict(fail);}
332if (x2[1][0]=='ABCD'O) {setverdict(pass);}
333 else {setverdict(fail);}
334if (x2[2][0]=='1234'O) {setverdict(pass);}
335 else {setverdict(fail);}
336if (x3[2][0]=='12CD'O) {setverdict(pass);} //out of order
337 else {setverdict(fail);}}
338
339testcase recofAssignElemSet() runs on recofOper_mycomp{
340var recofOper_myrecof5 x1,x2,x3 //record of set
341x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
342x2:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
343x1[0].x2:=3.4; //change element
344x2[2]:={ x1:=2, x2:=1.3 }; // add element
345x3[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[0].x1==1) {setverdict(pass);} //add element
355 else {setverdict(fail);}
356if (x2[0].x2==1.2) {setverdict(pass);}
357 else {setverdict(fail);}
358if (x2[1].x1==2) {setverdict(pass);}
359 else {setverdict(fail);}
360if (not(ispresent(x2[1].x2))) {setverdict(pass);}
361 else {setverdict(fail);}
362if (x2[2].x1==2) {setverdict(pass);}
363 else {setverdict(fail);}
364if (x2[2].x2==1.3) {setverdict(pass);}
365 else {setverdict(fail);}
366if (x3[2].x1==2) {setverdict(pass);} //out of order
367 else {setverdict(fail);}
368if (x3[2].x2==1.3) {setverdict(pass);}
369 else {setverdict(fail);}
370}
371
372testcase recofAssignElemSetof() runs on recofOper_mycomp{
373var recofOper_tsetof temp2:={"a","7"};
374var recofOper_myrecof6 x1,x2,x3; //record of set of
375x1:={ { "1" }, {"a","7"}};
376x2:={ { "1" }, {"a","7"}};
377x1[0][0]:="h"; // change element
378x2[2]:={"2"}; //add element
379x3[2]:={"2"}; //out of order
380if (x1[0][0]=="h") {setverdict(pass);} //change element
381 else {setverdict(fail);}
382if (x1[1][0]=="a") {setverdict(pass);}
383 else {setverdict(fail);}
384if (x1[1][1]=="7") {setverdict(pass);}
385 else {setverdict(fail);}
386if (x2[0][0]=="1") {setverdict(pass);} //add element
387 else {setverdict(fail);}
388if (x2[1][0]=="a") {setverdict(pass);}
389 else {setverdict(fail);}
390if (x2[1][1]=="7") {setverdict(pass);}
391 else {setverdict(fail);}
392if (x2[2][0]=="2") {setverdict(pass);}
393 else {setverdict(fail);}
394if (x3[2][0]=="2") {setverdict(pass);} // out of order
395 else {setverdict(fail);}
396}
397
398testcase recofAssignElemUnion() runs on recofOper_mycomp{
399var recofOper_tunion temp5 := {x2:=1.3}
400var recofOper_myrecof7 x1,x2,x3; //record of union
401x1:={ {x1 :=3 }, {x2:=1.3} };
402x2:={ {x1 :=3 }, {x2:=1.3} };
403x1[0].x2:=3.4; //change element
404x2[2]:={ x2:=1.4}; // add element
405x3[2]:={ x2:=1.4}; // out of order
406if (x1[0].x2==3.4) {setverdict(pass);} //change element
407 else {setverdict(fail);}
408if (ischosen(x1[0].x2)) {setverdict(pass);}
409 else {setverdict(fail);}
410if (not(ischosen(x1[0].x1))) {setverdict(pass);}
411 else {setverdict(fail);}
412if (x1[1].x2==1.3) {setverdict(pass);}
413 else {setverdict(fail);}
414if (ischosen(x1[1].x2)) {setverdict(pass);}
415 else {setverdict(fail);}
416if (not(ischosen(x1[1].x1))) {setverdict(pass);}
417 else {setverdict(fail);}
418if (x2[0].x1==3) {setverdict(pass);} //add element
419 else {setverdict(fail);}
420if (ischosen(x2[0].x1)) {setverdict(pass);}
421 else {setverdict(fail);}
422if (not(ischosen(x2[0].x2))) {setverdict(pass);}
423 else {setverdict(fail);}
424if (x2[1].x2==1.3) {setverdict(pass);}
425 else {setverdict(fail);}
426if (ischosen(x2[1].x2)) {setverdict(pass);}
427 else {setverdict(fail);}
428if (not(ischosen(x2[1].x1))) {setverdict(pass);}
429 else {setverdict(fail);}
430if (x2[2].x2==1.4) {setverdict(pass);}
431 else {setverdict(fail);}
432if (ischosen(x2[2].x2)) {setverdict(pass);}
433 else {setverdict(fail);}
434if (not(ischosen(x2[2].x1))) {setverdict(pass);}
435 else {setverdict(fail);}
436if (x3[2].x2==1.4) {setverdict(pass);} //out of order
437 else {setverdict(fail);}
438if (ischosen(x3[2].x2)) {setverdict(pass);}
439 else {setverdict(fail);}
440if (not(ischosen(x3[2].x1))) {setverdict(pass);}
441 else {setverdict(fail);}
442}
443
444testcase recofConst() runs on recofOper_mycomp{
445const recofOper_myrecof1 const1:={1,2,3} //record of basic types
446if (recofOper_const1[0]==1) {setverdict(pass);} //definition part
447 else {setverdict(fail);}
448if (recofOper_const1[1]==2) {setverdict(pass);}
449 else {setverdict(fail);}
450if (const1[0]==1) {setverdict(pass);} //testcase
451 else {setverdict(fail);}
452if (const1[1]==2) {setverdict(pass);}
453 else {setverdict(fail);}
454if (const1[2]==3) {setverdict(pass);}
455 else {setverdict(fail);}
456}
457
458testcase recofConstEnum() runs on recofOper_mycomp{
459const recofOper_myrecof2 const1:={xx1,xx2,xx3} //record of enumerated
460if (recofOper_const2[0]==xx2) {setverdict(pass);} //definition part
461 else {setverdict(fail);}
462if (recofOper_const2[1]==xx1) {setverdict(pass);}
463 else {setverdict(fail);}
464if (const1[0]==xx1) {setverdict(pass);} //testcase
465 else {setverdict(fail);}
466if (const1[1]==xx2) {setverdict(pass);}
467 else {setverdict(fail);}
468if (const1[2]==xx3) {setverdict(pass);}
469 else {setverdict(fail);}
470}
471
472testcase recofConstRec() runs on recofOper_mycomp{
473const recofOper_myrecof3 const4:={ //record of record
474 { x1:=1, x2:=1.2 }, recofOper_temp1 };
475if (recofOper_const4[0].x1==1) {setverdict(pass);} //definition part
476 else {setverdict(fail);}
477if (recofOper_const4[0].x2==1.2) {setverdict(pass);}
478 else {setverdict(fail);}
479if (recofOper_const4[1]==recofOper_temp1) {setverdict(pass);}
480 else {setverdict(fail);}
481if (const4[0].x1==1) {setverdict(pass);} //testcase
482 else {setverdict(fail);}
483if (const4[0].x2==1.2) {setverdict(pass);}
484 else {setverdict(fail);}
485if (const4[1]==recofOper_temp1) {setverdict(pass);}
486 else {setverdict(fail);}
487}
488
489testcase recofConstRecof() runs on recofOper_mycomp{
490const recofOper_myrecof4 const6:={ //record of record of
491 { '12AB'O, 'CD12'O }, recofOper_temp2 };
492if (recofOper_const6[0][0]=='12AB'O) {setverdict(pass);} //definition part
493 else {setverdict(fail);}
494if (recofOper_const6[0][1]=='CD12'O) {setverdict(pass);}
495 else {setverdict(fail);}
496if (recofOper_const6[1]==recofOper_temp2) {setverdict(pass);}
497 else {setverdict(fail);}
498if (const6[0][0]=='12AB'O) {setverdict(pass);} //testcase
499 else {setverdict(fail);}
500if (const6[0][1]=='CD12'O) {setverdict(pass);}
501 else {setverdict(fail);}
502if (const6[1]==recofOper_temp2) {setverdict(pass);}
503 else {setverdict(fail);}
504}
505
506testcase recofConstSet() runs on recofOper_mycomp{
507const recofOper_myrecof5 const8:={ //record of set
508 { x1:=2, x2:=1.3}, recofOper_temp3 };
509if (recofOper_const8[0].x1==2) {setverdict(pass);} //definition part
510 else {setverdict(fail);}
511if (recofOper_const8[0].x2==1.3) {setverdict(pass);}
512 else {setverdict(fail);}
513if (recofOper_const8[1]==recofOper_temp3) {setverdict(pass);}
514 else {setverdict(fail);}
515if (const8[0].x1==2) {setverdict(pass);} //testcase
516 else {setverdict(fail);}
517if (const8[0].x2==1.3) {setverdict(pass);}
518 else {setverdict(fail);}
519if (const8[1]==recofOper_temp3) {setverdict(pass);}
520 else {setverdict(fail);}
521}
522
523testcase recofConstSetof() runs on recofOper_mycomp{
524const recofOper_myrecof6 const10:={ //record of set of
525 {"a","b"}, {"f","8"} };
526if (recofOper_const10[0][0]=="a") {setverdict(pass);} //definition part
527 else {setverdict(fail);}
528if (recofOper_const10[0][1]=="b") {setverdict(pass);}
529 else {setverdict(fail);}
530if (recofOper_const10[1]==recofOper_temp4) {setverdict(pass);}
531 else {setverdict(fail);}
532if (const10[0][0]=="a") {setverdict(pass);} //testcase
533 else {setverdict(fail);}
534if (const10[0][1]=="b") {setverdict(pass);}
535 else {setverdict(fail);}
536if (const10[1][0]=="f") {setverdict(pass);}
537 else {setverdict(fail);}
538if (const10[1][1]=="8") {setverdict(pass);}
539 else {setverdict(fail);}
540}
541
542testcase recofConstUnion() runs on recofOper_mycomp{
543const recofOper_myrecof7 const12:={ //record of union
544 { x1 :=3 }, { x2:=1.3 } };
545if (recofOper_const12[0].x1==3) {setverdict(pass);} //definition part
546 else {setverdict(fail);}
547if (ischosen(recofOper_const12[0].x1)) {setverdict(pass);}
548 else {setverdict(fail);}
549if (not(ischosen(recofOper_const12[0].x2))) {setverdict(pass);}
550 else {setverdict(fail);}
551if (recofOper_const12[1]==recofOper_temp5) {setverdict(pass);}
552 else {setverdict(fail);}
553if (const12[0].x1==3) {setverdict(pass);} //testcase
554 else {setverdict(fail);}
555if (ischosen(const12[0].x1)) {setverdict(pass);}
556 else {setverdict(fail);}
557if (not(ischosen(const12[0].x2))) {setverdict(pass);}
558 else {setverdict(fail);}
559if (const12[1].x2==1.3) {setverdict(pass);}
560 else {setverdict(fail);}
561if (ischosen(const12[1].x2)) {setverdict(pass);}
562 else {setverdict(fail);}
563if (not(ischosen(const12[1].x1))) {setverdict(pass);}
564 else {setverdict(fail);}
565}
566
567
568testcase recofComp() runs on recofOper_mycomp{
569var recofOper_myrecof1 x1,x2,x3,x4; //record of basic type
570x1:={ 1,2,3 };
571x2:={ 1,2,3 };
572x3:={ 1,2 };
573x4:={3,1,2};
574if (x1==x2) {setverdict(pass);}
575 else {setverdict(fail);}
576if (not(x1==x3)) {setverdict(pass);}
577 else {setverdict(fail);}
578if (not(x1==x4)) {setverdict(pass);} // out of order
579 else {setverdict(fail);}
580if (x1!=x3) {setverdict(pass);}
581 else {setverdict(fail);}
582if (not(x1!=x2)) {setverdict(pass);}
583 else {setverdict(fail);}
584if (x1!=x4) {setverdict(pass);} // out of order
585 else {setverdict(fail);}
586}
587
588testcase recofCompEnum() runs on recofOper_mycomp{
589var recofOper_myrecof2 x1,x2,x3; // record of enumerated
590x1:={ xx1,xx2,xx3 };
591x2:={ xx1,xx2,xx3 };
592x3:={ xx1,xx2 };
593if (x1==x2) {setverdict(pass);}
594 else {setverdict(fail);}
595if (not(x1==x3)) {setverdict(pass);}
596 else {setverdict(fail);}
597if (x1!=x3) {setverdict(pass);}
598 else {setverdict(fail);}
599if (not(x1!=x2)) {setverdict(pass);}
600 else {setverdict(fail);}
601}
602
603testcase recofCompRec() runs on recofOper_mycomp{
604var recofOper_myrecof3 x1,x2,x3; // record of record
605x1 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
606x2 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
607x3 :={ { x1:=2, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
608if (x1==x2) {setverdict(pass);}
609 else {setverdict(fail);}
610if (not(x1==x3)) {setverdict(pass);}
611 else {setverdict(fail);}
612if (x1!=x3) {setverdict(pass);}
613 else {setverdict(fail);}
614if (not(x1!=x2)) {setverdict(pass);}
615 else {setverdict(fail);}
616}
617
618
619testcase recofCompRecof() runs on recofOper_mycomp{
620var recofOper_myrecof4 x1,x2,x3; //record of record of
621x1:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
622x2:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
623x3:={ { '12AB'O }, {'AF12'O} };
624if (x1==x2) {setverdict(pass);}
625 else {setverdict(fail);}
626if (not(x1==x3)) {setverdict(pass);}
627 else {setverdict(fail);}
628if (x2!=x3) {setverdict(pass);}
629 else {setverdict(fail);}
630if (not(x1!=x2)) {setverdict(pass);}
631 else {setverdict(fail);}
632}
633
634testcase recofCompSet() runs on recofOper_mycomp{
635var recofOper_tset temp1:={ x1:=2, x2:=omit };
636var recofOper_myrecof5 x1,x2,x3; //record of set
637x1:={ { x1:=1, x2:=1.2 }, temp1 };
638x2:={ { x2:=1.2, x1:=1 }, { x1:=2, x2:=omit }};
639x3:={ { x1:=1, x2:=1.2 } };
640if (x1==x2) {setverdict(pass);}
641 else {setverdict(fail);}
642if (not(x2==x3)) {setverdict(pass);}
643 else {setverdict(fail);}
644if (x1!=x3) {setverdict(pass);}
645 else {setverdict(fail);}
646if (not(x1!=x2)) {setverdict(pass);}
647 else {setverdict(fail);}
648}
649
650testcase recofCompSetof() runs on recofOper_mycomp{
651var recofOper_tsetof temp2:={"a","7"};
652var recofOper_myrecof6 x1,x2,x3; //record of set of
653x1:={ { "1", "a" }, temp2 };
654x2:={ { "1", "a" }, {"a","7"} };
655x3:={ { "1", "a" } };
656if (x1==x2) {setverdict(pass);}
657 else {setverdict(fail);}
658if (not(x2==x3)) {setverdict(pass);}
659 else {setverdict(fail);}
660if (x1!=x3) {setverdict(pass);}
661 else {setverdict(fail);}
662if (not(x1!=x2)) {setverdict(pass);}
663 else {setverdict(fail);}
664}
665
666testcase recofCompUnion() runs on recofOper_mycomp{
667var recofOper_tunion temp5 := {x2:=1.3}
668var recofOper_myrecof7 x1,x2,x3; //record of union
669x1:={ { x1 :=3 }, { x2:=1.3 } };
670x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
671x3:={ { x2 :=3.9 },temp5 }; //{ x2:=1.3 }
672if (x1==x2) {setverdict(pass);}
673 else {setverdict(fail);}
674if (not(x1==x3)) {setverdict(pass);}
675 else {setverdict(fail);}
676if (x2!=x3) {setverdict(pass);}
677 else {setverdict(fail);}
678if (not(x1!=x2)) {setverdict(pass);}
679 else {setverdict(fail);}
680}
681
682testcase recofEmpty() runs on recofOper_mycomp{
683 var recofOper_myrecof1 vl_list := {}
684 if (vl_list == {}) {setverdict(pass)}
685 else {setverdict(fail)}
686 if ({} == vl_list) {setverdict(pass)}
687 else {setverdict(fail)}
688}
689
690testcase recofListOperator() runs on recofOper_mycomp{
691 var recofOper_myrecof1 x1;
692 var recofOper_myrecof1 x2,x3,x4,x5,x6;
693 var recofOper_myrecof1 res1, res2, res3, res4;
694 x1:={1,2};
695 x2:={1,2};
696 x3:={1};
697 x4:={1};
698 x4[1]:=3;
699 x5:={};
700 x6[2]:=1;
701 res1 := x1 & x2;
702 res2 := x2 & x3;
703 res3 := x2 & x3 & x5;
704 res4 := x3 & x4;
705 if (res1 == {1,2,1,2}) {setverdict(pass);}
706 else {setverdict(fail);}
707 if (res2 == {1,2,1}) {setverdict(pass);}
708 else {setverdict(fail);}
709 if (res3 == {1,2,1}) {setverdict(pass);}
710 else {setverdict(fail);}
711 if (res4 == {1,1,3}) {setverdict(pass);}
712 else {setverdict(fail);}
713}
714
715testcase recofRotateOperators() runs on recofOper_mycomp{
716 var recofOper_myrecof1 x1:={1,2,3,4,5};
717 var recofOper_myrecof1 x2,x3,x4,x5,x6,x7; //set of basic types
718 x2 := x1 <@ 1;
719 x3 := x1 <@ 10;
720 x4 := x1 <@ 3 <@ 2;
721 x5 := x1 @> 1;
722 x6 := x1 @> 10;
723 x7 := x1 @> 3 @> 2;
724 if (x2 == {2,3,4,5,1}) {setverdict(pass);}
725 else {setverdict(fail);}
726 if (x3 == x1) {setverdict(pass);}
727 else {setverdict(fail);}
728 if (x4 == x1) {setverdict(pass);}
729 else {setverdict(fail);}
730 if (x5 == {5,1,2,3,4}) {setverdict(pass);}
731 else {setverdict(fail);}
732 if (x6 == x1) {setverdict(pass);}
733 else {setverdict(fail);}
734 if (x7 == x1) {setverdict(pass);}
735 else {setverdict(fail);}
736}
737
738testcase recofLengthof() runs on recofOper_mycomp{
739 var recofOper_myrecof1 x1:={1,2};
740 var recofOper_myrecof1 x2,x3,x4,x5,x6; //record of basic types
741 x2:={ 1, 2 };
742 x3:={1};
743 x4:={1};
744 x3:={1,2}; //change size by assignment
745 x4[1]:=3; //change size by adding element
746 x5:={}; //empty record of
747 x6[2]:=1; //out of order
748 if (lengthof(x1)==2) {setverdict(pass);} //assignment at declaration
749 else {setverdict(fail);}
750 if (lengthof(x2)==2) {setverdict(pass);} //assignment later
751 else {setverdict(fail);}
752 if (lengthof(x3)==2) {setverdict(pass);} //change size by assignment
753 else {setverdict(fail);}
754 if (lengthof(x4)==2) {setverdict(pass);} //change size by adding element
755 else {setverdict(fail);}
756 if (lengthof(x5)==0) {setverdict(pass);} //empty record of
757 else {setverdict(fail);}
758 if (lengthof(x6)==3) {setverdict(pass);} //out of order
759 else {setverdict(fail);}
760}
761
762testcase recofSizeof() runs on recofOper_mycomp{
763 var recofOper_myrecof1 x1:={1,2};
764 var recofOper_myrecof1 x2,x3,x4,x5,x6; //record of basic types
765 x2:={ 1, 2 };
766 x3:={1};
767 x4:={1};
768 x3:={1,2}; //change size by assignment
769 x4[1]:=3; //change size by adding element
770 x5:={}; //empty record of
771 x6[2]:=1; //out of order
772 if (sizeof(x1)==2) {setverdict(pass);} //assignment at declaration
773 else {setverdict(fail);}
774 if (sizeof(x2)==2) {setverdict(pass);} //assignment later
775 else {setverdict(fail);}
776 if (sizeof(x3)==2) {setverdict(pass);} //change size by assignment
777 else {setverdict(fail);}
778 if (sizeof(x4)==2) {setverdict(pass);} //change size by adding element
779 else {setverdict(fail);}
780 if (sizeof(x5)==0) {setverdict(pass);} //empty record of
781 else {setverdict(fail);}
782 if (sizeof(x6)==3) {setverdict(pass);} //out of order
783 else {setverdict(fail);}
784}
785
786testcase recofReplace() runs on recofOper_mycomp{
787 var recofOper_myrecof1 x1:={1,2,3,4,5};
788 var recofOper_myrecof1 a:={8,8,8};
789 var recofOper_myrecof1 x2;
790 x2 := replace(x1,2,3,a);
791 if (x2 == {1,2,8,8,8}) {setverdict(pass);}
792 else {setverdict(fail);}
793}
794
795// TR: HS22809 - A null value is generated for empty constant arrays by the compiler,
796// this can make calling 'replace' ambiguous (since there's a 'replace' function generated for both the
797// array and its template.
798testcase recofReplaceEmpty() runs on recofOper_mycomp {
799 var recofOper_myrecof1 x1 := { 1, 2, 3 };
800 const recofOper_myrecof1 a := {};
801 var recofOper_myrecof1 x2;
802 x2 := replace(x1, 0, 1, a);
803 if (x2 == { 2, 3 }) { setverdict(pass); }
804 else { setverdict(fail); }
805}
806
807testcase recofSubstr() runs on recofOper_mycomp{
808 var recofOper_myrecof1 x1:={1,2,3,4,5};
809 var recofOper_myrecof1 x2;
810 x2 := substr(x1,2,3);
811 if (x2 == {3,4,5}) {setverdict(pass);}
812 else {setverdict(fail);}
813}
814
815type record intrec { recofOper_myrecof1 a }
816type record of intrec intreclist
817
818testcase recofIsvalue() runs on recofOper_mycomp{
819 var recofOper_myrecof1 v_def;
820 var recofOper_myrecof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
821 var recofOper_myrecof1 v_full := {1,2,3,4,5,6,7,8,9,10}
822
823 if ( isvalue(v_def) ) { setverdict(fail); }else { setverdict(pass); };
824 if ( isvalue(v_empty) ) { setverdict(fail); } else { setverdict(pass); };
825 if ( isvalue(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
826 if ( isvalue(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
827 if ( isvalue(v_full[1]) ) { setverdict(pass); } else { setverdict(fail); };
828
829 v_def[1] := 3;
830 if ( isvalue(v_def) ) { setverdict(fail); } else { setverdict(pass); };
831 if ( isvalue(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
832 if ( isvalue(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
833
834 v_empty[0] := 17; // not empty anymore
835 if ( isvalue(v_empty[0]) ) { setverdict(pass); } else { setverdict(fail); };
836 if ( isvalue(v_empty) ) { setverdict(fail); } else { setverdict(pass); };
837
838 template intreclist it1 := { { a := { 1, 2, 3 } } };
839 template intreclist it2 modifies it1 := { { a := { 1, 2, -, -, -, 100 } } };
840 template intrec itt1 := { a := { 1, 2, 3 } };
841 template intrec itt2 modifies itt1 := { a := { 1, 2, -, -, -, 100 } };
842 if (isvalue (it1)) {setverdict (pass);}
843 else {setverdict (fail);}
844
845 if (isvalue (it2)) { setverdict (fail);}
846 else { setverdict (pass);}
847
848 if (isvalue (itt1)) {setverdict (pass);}
849 else {setverdict ( fail );}
850
851 if (isvalue (itt2)) { setverdict (fail);}
852 else {setverdict (pass);}
853
854 const threeD d3 := {
855 {
856 { 1,2,3 },
857 { 1,2,3 },
858 { 1,2,3 }
859 },
860 {
861 { 1,2,3 },
862 { 1,2,3 },
863 { 1,2,3 }
864 },
865 {
866 { 1,2,3 },
867 { 1,2,3 },
868 { 1,2,3 }
869 }
870 }
871 var threeD nowhere := {
872 { {-,1,-},{-,1,-},{-,1,-} },
873 { {-,1,-},{-,-,-},{-,1,-} },
874 { {-,1,-},{-,1,-},{-,1,-} }
875
876 }
877 if ( isvalue(nowhere) ) { setverdict(fail); } else { setverdict(pass); };
878 if ( isvalue(nowhere[1]) ) { setverdict(fail); } else { setverdict(pass); };
879 if ( isvalue(nowhere[1][1]) ) { setverdict(fail); } else { setverdict(pass); };
880 if ( isvalue(nowhere[1][1][1]) ) { setverdict(fail); } else { setverdict(pass); };
881 if ( isvalue(d3) ) { setverdict(pass); } else { setverdict(fail); };
882 if ( isvalue(d3[0]) ) { setverdict(pass); } else { setverdict(fail); };
883 if ( isvalue(d3[0][1]) ) { setverdict(pass); } else { setverdict(fail); };
884 if ( isvalue(d3[0][1][2]) ) { setverdict(pass); } else { setverdict(fail); };
885}
886
887testcase recofIsvalue2() runs on recofOper_mycomp{
888 var recofOper_myrecof1 v;
889 if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
890
891 v[3] := 3;
892 if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
893
894 v[2] := 2;
895 if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
896
897 v[1] := 1;
898 if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
899
900 v[0] := 0;
901 if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };
902
903 v[4] := 4;
904 if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };
905
906 v[6] := 6; // there is now a hole at 5
907 if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
908}
909
910testcase recofIsbound() runs on recofOper_mycomp{
911 var recofOper_myrecof1 v_def;
912 var recofOper_myrecof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
913 var recofOper_myrecof1 v_full := {1,2,3,4,5,6,7,8,9,10}
914
915 if ( isbound(v_def) ) { setverdict(fail); }else { setverdict(pass); };
916 if ( isbound(v_empty) ) { setverdict(pass); } else { setverdict(fail); };
917 if ( isbound(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
918 if ( isbound(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
919 if ( isbound(v_full[1]) ) { setverdict(pass); } else { setverdict(fail); };
920
921 v_def[1] := 3;
922 if ( isbound(v_def) ) { setverdict(pass); } else { setverdict(fail); };
923 if ( isbound(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
924 if ( isbound(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
925
926 v_empty[0] := 17; // not empty anymore
927 if ( isbound(v_empty[0]) ) { setverdict(pass); } else { setverdict(fail); };
928
929 template intreclist it1 := { { a := { 1, 2, 3 } } };
930 template intreclist it2 modifies it1 := { { a := { 1, 2, -, -, -, 100 } } };
931 template intrec itt1 := { a := { 1, 2, 3 } };
932 template intrec itt2 modifies itt1 := { a := { 1, 2, -, -, -, 100 } };
933 if (isbound (it1)) { setverdict(pass); } else { setverdict(fail); };
934 if (isbound (it2)) { setverdict(pass); } else { setverdict(fail); };
935 if (isbound (itt1)) { setverdict(pass); } else { setverdict(fail); };
936 if (isbound (itt2)) { setverdict(pass); } else { setverdict(fail); };
937
938 var threeD d3_emtpy;
939 const threeD d3 := {
940 {
941 { 1,2,3 },
942 { 1,2,3 },
943 { 1,2,3 }
944 },
945 {
946 { 1,2,3 },
947 { 1,2,3 },
948 { 1,2,3 }
949 },
950 {
951 { 1,2,3 },
952 { 1,2,3 },
953 { 1,2,3 }
954 }
955 }
956 var threeD nowhere := {
957 { {-,1,-},{-,1,-},{-,1,-} },
958 { {-,1,-},{-,-,-},{-,1,-} },
959 { {-,1,-},{-,1,-},{-,1,-} }
960 }
961
962 if ( isbound(d3_emtpy) ) { setverdict(fail); } else { setverdict(pass); };
963 if ( isbound(d3_emtpy[0]) ) { setverdict(fail); } else { setverdict(pass); };
964 if ( isbound(d3_emtpy[0][1]) ) { setverdict(fail); } else { setverdict(pass); };
965 if ( isbound(d3_emtpy[0][1][2]) ) { setverdict(fail); } else { setverdict(pass); };
966
967 if ( isbound(nowhere) ) { setverdict(pass); } else { setverdict(fail); };
968 if ( isbound(nowhere[1]) ) { setverdict(pass); } else { setverdict(fail); };
969 if ( isbound(nowhere[1][1]) ) { setverdict(pass); } else { setverdict(fail); };
970 if ( isbound(nowhere[1][1][1]) ) { setverdict(fail); } else { setverdict(pass); };
971 if ( isbound(d3) ) { setverdict(pass); } else { setverdict(fail); };
972 if ( isbound(d3[0]) ) { setverdict(pass); } else { setverdict(fail); };
973 if ( isbound(d3[0][1]) ) { setverdict(pass); } else { setverdict(fail); };
974 if ( isbound(d3[0][1][2]) ) { setverdict(pass); } else { setverdict(fail); };
975}
976
977testcase recofCompConst() runs on recofOper_mycomp{
978 const recofOper_myrecof1 c_r1 := { 1,2,3,4};
979 const recofOper_myrecof1 c_r2 := { 1,2,3,4};
980 const recofOper_myrecof1 c_r3 := { 4,3,2,1};
981 const recofOper_myrecof1 c_r4_ind := { [0] := 1, [1] := 2, [2] := 3, [3] := 4};
982 const recofOper_myrecof1 c_r5_ind := { [3] := 1, [1] := 2, [2] := 3, [0] := 4};
983 const recofOper_myrecof1 c_r6_ind := { [3] := 4, [1] := 2, [2] := 3, [0] := 1};
984 const recofOper_myrecof1 c_r8_ind := { [0] := 1, [1] := 2, [2] := 3, [3] := 4};
985
986
987 var recofOper_myrecof1 vl_r7_ind := { [3] := 4, [1] := 2};
988
989 var recofOper_myrecof1 vl_r10 := { 1,2,3,4};
990 var recofOper_myrecof1 vl_r11 := { 1,2,3,4};
991
992 if(c_r1 == c_r1) {setverdict(pass);}
993 else {setverdict(fail);}
994
995 if(c_r1 == c_r2) {setverdict(pass);}
996 else {setverdict(fail);}
997
998 if(c_r1 == c_r4_ind) {setverdict(pass);}
999 else {setverdict(fail);}
1000
1001 if(c_r4_ind == c_r4_ind) {setverdict(pass);}
1002 else {setverdict(fail);}
1003
1004 if(c_r1 == c_r6_ind) {setverdict(pass);}
1005 else {setverdict(fail);}
1006
1007
1008 if(c_r1 != vl_r7_ind) {setverdict(pass);}
1009 else { setverdict(fail);}
1010
1011 if(c_r4_ind == c_r8_ind) {setverdict(pass); }
1012 else {setverdict(fail);}
1013
1014 if(vl_r10 == vl_r11) {setverdict(pass);}
1015 else {setverdict(fail);}
1016}
1017
1018type record length(10) of integer MyRecordOfType10
1019type record length(0..10) of integer MyRecordOfType0_10
1020type record length(10..infinity) of integer MyRecordOfType10up
1021type record length(0..10) of charstring StringArray length(12)
1022type record of record of charstring StringArrayTwo length(12)
1023type record of charstring MyRecof2 ("a", "aa", "aaa", "aaaa") length(2)
1024type record length(2) of charstring MyRecof3 ("a", "aa", "aaa", "aaaa")
1025type record length(2) of charstring MyRecof4 ("a", "aa", "aaa", "aaaa") length(2)
1026// TODO: Add additional subtypes here.
1027type MyRecof2 MyRecof5
1028type MyRecof3 MyRecof6
1029type MyRecof4 MyRecof7
1030type MyRecof2 MyRecof8 ({"aa"})
1031type record of integer MyRecof9 (1..10, 100)
1032
1033const MyRecof2 c_myrecof1 := {}
1034const MyRecof2 c_myrecof2 := {"aa", "aa"}
1035const MyRecof2 c_myrecof3 := {c_myrecof2[0], c_myrecof2[1]}
1036const MyRecof3 c_myrecof4 := {"a", "aa"}
1037const MyRecof3 c_myrecof5 := {c_myrecof4[0], c_myrecof4[1]}
1038const MyRecof4 c_myrecof6 := {"aa", "aa"}
1039const MyRecof4 c_myrecof7 := {c_myrecof6[0], c_myrecof6[1]}
1040const MyRecof8 c_myrecof8 := {"aa"}
1041const MyRecof9 c_myrecof9 := {1, 100}
1042
1043template MyRecof2 t_myrecof1 := {}
1044template MyRecof2 t_myrecof2 := {"aa", "aa"}
1045template MyRecof2 t_myrecof3 := c_myrecof2
1046template MyRecof3 t_myrecof4 := {"a", "aa"}
1047template MyRecof3 t_myrecof5 := c_myrecof5
1048template MyRecof4 t_myrecof6 := {"aa", "aa"}
1049template MyRecof4 t_myrecof7 := c_myrecof7
1050template MyRecof8 t_myrecof8 := {"aa"}
1051template MyRecof9 t_myrecof9 := {1, 100} length(2)
1052
1053testcase recofSubtype() runs on recofOper_mycomp {
1054 var template MyRecordOfType10 vt_myrecof1 := { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
1055 var MyRecordOfType10 v_myrecof1 := { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
1056 if (substr(v_myrecof1, 0, 2) == substr(vt_myrecof1, 1, 2)) { setverdict(pass) }
1057 else { setverdict(fail) }
1058}
1059
1060type record of charstring ROC;
1061type record of integer ROI;
1062type record MyRecord1 {
1063 integer i optional,
1064 float x optional,
1065 charstring c
1066}
1067
1068type record of ROI ROROI;
1069
1070type union MyUnion1 {
1071 ROC roc,
1072 integer i,
1073 ROI roi,
1074 MyRecord1 r
1075}
1076
1077type record MyRec2 {
1078 ROC roc optional,
1079 ROI roi optional,
1080 MyUnion1 u optional,
1081 MyRecord1 r optional
1082}
1083
1084type record of MyRec2 MyRecOf
1085
1086type record MyRec3 {
1087 ROROI roroi optional,
1088 MyRec2 r optional
1089}
1090
1091const MyRec2 c_myrec2_1:={
1092 roc:=omit,
1093 roi:={},
1094 u:={r:={ i:=1, x:=1.0, c:="one"}},
1095 r:={ i:=1, x:=1.0, c:="one"}
1096}
1097
1098const MyRec3 c_myrec3_1 := {
1099 roroi:= { {1,2,3,4,5,6,7,8,9},{10} },
1100 r:= omit
1101}
1102
1103const MyRec3 c_myrec3_2 := {
1104 roroi:= { {1,2,3,4,5,6,7,8,9},{10} },
1105 r:= {
1106 roc:={},
1107 roi:={},
1108 u:={i:=5},
1109 r:=omit
1110 }
1111}
1112
1113const MyRec3 c_myrec3_innerOmits := {
1114 roroi:= { {1,2,3,4,5,6,7,8,9},{10} },
1115 r:= {
1116 roc:=omit,
1117 roi:=omit,
1118 u:=omit,
1119 r:=omit
1120 }
1121}
1122
1123testcase tc_recordOf_omit1() runs on recofOper_mycomp {
1124 var MyRec2 vl_r1:=c_myrec2_1;
1125 if(isbound(vl_r1.roc)){setverdict(pass)}else {setverdict(fail)};
1126 var MyRec2 vl_r2:=c_myrec2_1;
1127 if(isbound(vl_r2.roc[0])){setverdict(fail)}else {setverdict(pass)};
1128 var MyRec2 vl_r3:=c_myrec2_1;
1129 if(isbound(vl_r3.roi)){setverdict(pass)}else {setverdict(fail)};
1130 var MyRec2 vl_r4:=c_myrec2_1;
1131 if(isbound(vl_r4.roi[0])){setverdict(fail)}else {setverdict(pass)};
1132 var MyRec2 vl_r5:=c_myrec2_1;
1133 if(isbound(vl_r5.roi[90])){setverdict(fail)}else {setverdict(pass)};
1134}
1135
1136testcase tc_recordOf_union() runs on recofOper_mycomp {
1137 var MyRec2 vl_r:=c_myrec2_1;
1138 if(isbound(vl_r.u)){setverdict(pass)}else {setverdict(fail)};
1139 if(isbound(vl_r.u.r)){setverdict(pass)}else {setverdict(fail)};
1140 if(isbound(vl_r.u.r.i)){setverdict(pass)}else {setverdict(fail)};
1141 if(isbound(vl_r.u.r.x)){setverdict(pass)}else {setverdict(fail)};
1142 if(isbound(vl_r.u.r.c)){setverdict(pass)}else {setverdict(fail)};
1143 if(isbound(vl_r.u.roi)){setverdict(fail)}else {setverdict(pass)};
1144 if(isbound(vl_r.u.roi[3])){setverdict(fail)}else {setverdict(pass)};
1145 if(isbound(vl_r.u.i)){setverdict(fail)}else {setverdict(pass)};
1146 if(isbound(vl_r.u.roc)){setverdict(fail)}else {setverdict(pass)};
1147 if(isbound(vl_r.u.roc[0])){setverdict(fail)}else {setverdict(pass)};
1148}
1149
1150testcase tc_recordOf_recordOfRecordOfInt() runs on recofOper_mycomp {
1151 var MyRec3 vl_r:=c_myrec3_1;
1152 if(isbound(vl_r.roroi)){setverdict(pass)}else {setverdict(fail)};
1153 if(isbound(vl_r.roroi[0])){setverdict(pass)}else {setverdict(fail)};
1154 if(isbound(vl_r.roroi[1])){setverdict(pass)}else {setverdict(fail)};
1155 if(isbound(vl_r.roroi[2])){setverdict(fail)}else {setverdict(pass)};
1156 if(isbound(vl_r.roroi[200])){setverdict(fail)}else {setverdict(pass)};
1157 if(isbound(vl_r.roroi[0][0])){setverdict(pass)}else {setverdict(fail)};
1158 if(isbound(vl_r.roroi[0][8])){setverdict(pass)}else {setverdict(fail)};
1159 if(isbound(vl_r.roroi[0][9])){setverdict(fail)}else {setverdict(pass)};
1160 if(isbound(vl_r.roroi[1][0])){setverdict(pass)}else {setverdict(fail)};
1161 if(isbound(vl_r.roroi[1][1])){setverdict(fail)}else {setverdict(pass)};
1162 if(isbound(vl_r.roroi[2][0])){setverdict(fail)}else {setverdict(pass)};
1163}
1164
1165testcase tc_recordOf_recordInRecord() runs on recofOper_mycomp {
1166 var MyRec3 vl_r:=c_myrec3_2;
1167 if(isbound(vl_r.r)) {setverdict(pass)}else {setverdict(fail)};
1168 if(isbound(vl_r.r.roc)) {setverdict(pass)}else {setverdict(fail)};
1169 if(isbound(vl_r.r.roi)) {setverdict(pass)}else {setverdict(fail)};
1170 if(isbound(vl_r.r.u)) {setverdict(pass)}else {setverdict(fail)};
1171 if(isbound(vl_r.r.u)) {setverdict(pass)}else {setverdict(fail)};
1172 if(isbound(vl_r.r.u.i)) {setverdict(pass)}else {setverdict(fail)};
1173 if(isbound(vl_r.r.r)) {setverdict(pass)}else {setverdict(fail)}; //fails!
1174}
1175
1176testcase tc_recordOf_recordInRecord_innerOmits() runs on recofOper_mycomp {
1177 var MyRec3 vl_r:=c_myrec3_innerOmits;
1178 if(isbound(vl_r.roroi)) {setverdict(pass)}else {setverdict(fail)};
1179 if(isbound(vl_r.r)) {setverdict(pass)}else {setverdict(fail)};
1180 if(isbound(vl_r.r.roc)) {setverdict(pass)}else {setverdict(fail)};
1181 if(isbound(vl_r.r.roi)) {setverdict(pass)}else {setverdict(fail)};
1182 if(isbound(vl_r.r.u)) {setverdict(pass)}else {setverdict(fail)};
1183 if(isbound(vl_r.r.r)){setverdict(pass)}else {setverdict(fail)};
1184}
1185
1186 testcase tc_recordOf_union_ispresent() runs on recofOper_mycomp {
1187 var MyRec2 vl_r:=c_myrec2_1;
1188 if(ispresent(vl_r.u)){setverdict(pass)}else {setverdict(fail)};
1189 if(ispresent(vl_r.u.r)){setverdict(pass)}else {setverdict(fail)};
1190 if(ispresent(vl_r.u.r.i)){setverdict(pass)}else {setverdict(fail)};
1191 if(ispresent(vl_r.u.r.x)){setverdict(pass)}else {setverdict(fail)};
1192 if(ispresent(vl_r.u.r.c)){setverdict(pass)}else {setverdict(fail)};
1193 if(ispresent(vl_r.u.roi)){setverdict(fail)}else {setverdict(pass)};
1194 if(ispresent(vl_r.u.roi[3])){setverdict(fail)}else {setverdict(pass)};
1195 if(ispresent(vl_r.u.i)){setverdict(fail)}else {setverdict(pass)};
1196 if(ispresent(vl_r.u.roc)){setverdict(fail)}else {setverdict(pass)};
1197 if(ispresent(vl_r.u.roc[0])){setverdict(fail)}else {setverdict(pass)};
1198 }
1199
1200 testcase tc_recordOf_recordOfRecordOfInt_ispresent() runs on recofOper_mycomp {
1201 var MyRec3 vl_r:=c_myrec3_1;
1202 if(ispresent(vl_r.roroi)){setverdict(pass)}else {setverdict(fail)};
1203 if(ispresent(vl_r.roroi[0])){setverdict(pass)}else {setverdict(fail)};
1204 if(ispresent(vl_r.roroi[1])){setverdict(pass)}else {setverdict(fail)};
1205 if(ispresent(vl_r.roroi[2])){setverdict(fail)}else {setverdict(pass)};
1206 if(ispresent(vl_r.roroi[200])){setverdict(fail)}else {setverdict(pass)};
1207 if(ispresent(vl_r.roroi[0][0])){setverdict(pass)}else {setverdict(fail)};
1208 }
1209
1210 testcase tc_recordOf_recordOfRecordOfInt2() runs on recofOper_mycomp {
1211 var MyRec3 vl_r:=c_myrec3_1;
1212 if(ispresent(vl_r.roroi[0][8])){setverdict(pass)}else {setverdict(fail)};
1213 if(ispresent(vl_r.roroi[0][9])){setverdict(fail)}else {setverdict(pass)};
1214 if(ispresent(vl_r.roroi[1][0])){setverdict(pass)}else {setverdict(fail)};
1215 if(ispresent(vl_r.roroi[1][1])){setverdict(fail)}else {setverdict(pass)};
1216 if(ispresent(vl_r.roroi[2][0])){setverdict(fail)}else {setverdict(pass)};
1217 }
1218
1219 testcase tc_recordOf_recordInRecord_ispresent() runs on recofOper_mycomp {
1220 var MyRec3 vl_r:=c_myrec3_2;
1221 if(ispresent(vl_r.r)) {setverdict(pass)}else {setverdict(fail)};
1222 if(ispresent(vl_r.r.roc)) {setverdict(pass)}else {setverdict(fail)};
1223 if(ispresent(vl_r.r.roi)) {setverdict(pass)}else {setverdict(fail)};
1224 if(ispresent(vl_r.r.u)) {setverdict(pass)}else {setverdict(fail)};
1225 if(ispresent(vl_r.r.u)) {setverdict(pass)}else {setverdict(fail)};
1226 if(ispresent(vl_r.r.u.i)) {setverdict(pass)}else {setverdict(fail)};
1227 }
1228
1229 testcase tc_recordOf_recordInRecord2() runs on recofOper_mycomp {
1230 var MyRec3 vl_r:=c_myrec3_2;
1231 if(ispresent(vl_r.r.r)) {setverdict(fail)}else {setverdict(pass)};
1232 }
1233
1234 testcase tc_recordOf_recordInRecord_innerOmits_ispresent() runs on recofOper_mycomp {
1235 var MyRec3 vl_r:=c_myrec3_innerOmits;
1236 if(ispresent(vl_r.roroi)) {setverdict(pass)}else {setverdict(fail)};
1237 if(ispresent(vl_r.r)) {setverdict(pass)}else {setverdict(fail)};
1238 if(ispresent(vl_r.r.roc)) {setverdict(fail)}else {setverdict(pass)};
1239 if(ispresent(vl_r.r.roi)) {setverdict(fail)}else {setverdict(pass)};
1240 if(ispresent(vl_r.r.u)) {setverdict(fail)}else {setverdict(pass)};
1241 if(ispresent(vl_r.r.r)){setverdict(fail)}else {setverdict(pass)};
1242 }
1243
1244type record length(6) of integer MyArray6;
1245
1246//TR: HO84027
1247testcase tc_sizeof_lengthof_roi_bugs() runs on recofOper_mycomp {
1248 var template ROI vlt_roi :={}
1249 var integer vl_array[6];
1250 var MyArray6 vl_array6;
1251 var template MyArray6 vlt_array6;
1252
1253 vlt_roi[0]:=0;
1254 vlt_roi[5]:=0;
1255
1256 vl_array[0]:=0;
1257 vl_array[4]:=0;
1258
1259 vl_array6[0]:=0;
1260 vl_array6[4]:=0;
1261
1262 vlt_array6[0]:=0;
1263 vlt_array6[4]:=0;
1264
1265 if(sizeof(vlt_roi)==6) { setverdict(pass) } else { setverdict(fail) };
1266 if(lengthof(vlt_roi)==6) { setverdict(pass) } else { setverdict(fail) };
1267
1268 if(sizeof(vl_array)==6) { setverdict(pass) } else { setverdict(fail) };
1269 if(lengthof(vl_array)==5) { setverdict(pass) } else { setverdict(fail) };
1270
1271 if(sizeof(vl_array6)==5) { setverdict(pass) } else { setverdict(fail) };
1272 if(lengthof(vl_array6)==5) { setverdict(pass) } else { setverdict(fail) };
1273
1274 if(sizeof(vlt_array6)==5) { setverdict(pass) } else { setverdict(fail) };
1275 if(lengthof(vlt_array6)==5){ setverdict(pass) } else { setverdict(fail) };
1276}
1277
1278testcase tc_sizeof_lengthof_standard1() runs on recofOper_mycomp {
1279 if(lengthof(bitstring : '010'B) == 3) { setverdict(pass)} else { setverdict(fail) };
1280 if(lengthof(hexstring : 'F3'H) == 2) { setverdict(pass)} else { setverdict(fail) };
1281 if(lengthof(octetstring : 'F2'O) == 1) { setverdict(pass)} else { setverdict(fail) };
1282 if(lengthof (universal charstring : "Length_of_Example")==17) { setverdict(pass)}else { setverdict(fail) };
1283 if(lengthof(charstring : "HELLO") == 5) { setverdict(pass)}else { setverdict(fail) };
1284 if(lengthof(octetstring : ('12'O, '34'O))==1){ setverdict(pass)}else { setverdict(fail) };
1285 if(lengthof('1??1'B)==4){ setverdict(pass)}else { setverdict(fail) };
1286 if(lengthof(universal charstring : ? length(8))==8 ) { setverdict(pass)}else { setverdict(fail) }; //DTE
1287 if(lengthof('1*F'H length (8)) ==8){ setverdict(pass)}else { setverdict(fail) };
1288 if(lengthof('00*FF'O length(1..2))==2) { setverdict(pass)}else { setverdict(fail) };
1289}
1290
1291type record length(0..10) of integer MyList;
1292
1293testcase tc_sizeof_lengthof_standard2() runs on recofOper_mycomp {
1294 var MyList vl_MyListVar := { 0, 1, -, 2, - };
1295 log("vl_MyListVar: ",vl_MyListVar);
1296 if(lengthof(vl_MyListVar)==4) { setverdict(pass)}else { setverdict(fail) };
1297}
1298
1299testcase tc_sizeof_lengthof_standard4() runs on recofOper_mycomp {
1300 template ROI tr_roI3 := { 1, *, 10 } length(5)
1301 if(lengthof(tr_roI3)==5){ setverdict(pass)}else { setverdict(fail) };
1302}
1303
1304testcase tc_sizeof_lengthof_standard6() runs on recofOper_mycomp {
1305 template ROI tr_roI5 := { 1, 2, 3, * } length(1..3)
1306 if(lengthof(tr_roI5)==3) { setverdict(pass)}else { setverdict(fail) };
1307}
1308
1309control {
1310 const recofOper_trecord cl_temp1:={ x1:=omit, x2:=3.4 }; // constants in the control part
1311 const recofOper_trecof cl_temp2:={ 'AF12'O };
1312 const recofOper_tset cl_temp3:={ x1:=234, x2:=1.9};
1313 const recofOper_tsetof cl_temp4:={"f","8"};
1314 const recofOper_tunion cl_temp5:={ x2:=1.3 };
1315 const recofOper_trecord vl_temp1:={ x1:=omit, x2:=3.4 }; // variables in the control part
1316 const recofOper_trecof vl_temp2:={ 'AF12'O };
1317 const recofOper_tset vl_temp3:={ x1:=234, x2:=1.9};
1318 const recofOper_tsetof vl_temp4:={"f","8"};
1319 const recofOper_tunion vl_temp5:={ x2:=1.3 };
1320
1321 execute(recofAssign());
1322 execute(recofReAssign());
1323 execute(recofAssignEnum());
1324 execute(recofAssignRec());
1325 execute(recofAssignRecof());
1326 execute(recofAssignSet());
1327 execute(recofAssignSetof());
1328 execute(recofAssignUnion());
1329 execute(recofAssignElem());
1330 execute(recofAssignElemEnum());
1331 execute(recofAssignElemRec());
1332 execute(recofAssignElemRecof());
1333 execute(recofAssignElemSet());
1334 execute(recofAssignElemSetof());
1335 execute(recofAssignElemUnion());
1336 execute(recofConst());
1337 execute(recofConstEnum());
1338 execute(recofConstRec());
1339 execute(recofConstRecof());
1340 execute(recofConstSet());
1341 execute(recofConstSetof());
1342 execute(recofConstUnion());
1343 execute(recofComp());
1344 execute(recofCompConst());
1345 execute(recofCompEnum());
1346 execute(recofCompRec());
1347 execute(recofCompRecof());
1348 execute(recofCompSet());
1349 execute(recofCompSetof());
1350 execute(recofCompUnion());
1351 execute(recofEmpty());
1352
1353 execute(recofListOperator());
1354 execute(recofRotateOperators());
1355 execute(recofLengthof());
1356 execute(recofSizeof());
1357 execute(recofReplace());
1358 execute(recofReplaceEmpty());
1359 execute(recofSubstr());
1360 execute(recofIsvalue());
1361 execute(recofIsvalue2());
1362 execute(recofIsbound());
1363
1364 execute(recofSubtype());
1365
1366 execute(tc_recordOf_omit1());
1367 execute(tc_recordOf_union());
1368 execute(tc_recordOf_recordOfRecordOfInt());
1369 execute(tc_recordOf_recordInRecord());
1370 execute(tc_recordOf_recordInRecord_innerOmits());
1371 execute(tc_recordOf_union_ispresent());
1372 execute(tc_recordOf_recordOfRecordOfInt_ispresent());
1373 execute(tc_recordOf_recordOfRecordOfInt2());
1374 execute(tc_recordOf_recordInRecord_ispresent());
1375 execute(tc_recordOf_recordInRecord2());
1376 execute(tc_recordOf_recordInRecord_innerOmits_ispresent());
1377 execute(tc_sizeof_lengthof_roi_bugs());
1378 execute(tc_sizeof_lengthof_standard1());
1379 execute(tc_sizeof_lengthof_standard2());
1380 execute(tc_sizeof_lengthof_standard4());
1381 execute(tc_sizeof_lengthof_standard6());
1382}
1383
1384}
Titan Core - Deliverables
This page took 0.129528 seconds and 5 git commands to generate.