projects / deliverable / titan.core.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Sync with 5.4.3
[deliverable/titan.core.git] / regression_test / recordOper / TrecordOper.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 TrecordOper {
9// ********** Type definitions *********************
10type component recordOper_mycomp {};
11type enumerated recordOper_myenum {xx1,xx2,xx3};
12type record recordOper_empty {};
13type record recordOper_trecord {
14 integer x1 optional,
15 float x2 };
16type record of octetstring recordOper_trecof;
17type set recordOper_tset {
18 integer x1,
19 float x2 optional };
20type set of charstring recordOper_tsetof;
21type union recordOper_tunion {
22 integer x1,
23 float x2 };
24type record recordOper_myrec1 { // record from basic types
25 integer x1,
26 float x2,
27 recordOper_myenum x3 };
28type record recordOper_myrec2 { // record from basic types, with optional field
29 integer x1,
30 float x2,
31 recordOper_myenum x3,
32 integer x4 optional };
33type record recordOper_myrec3 { // record from record, with optional field
34 recordOper_trecord x1,
35 recordOper_trecord x2 optional
36 };
37type record recordOper_myrec4 { // record from record of, with optional field
38 recordOper_trecof x1,
39 recordOper_trecof x2 optional
40 };
41type record recordOper_myrec5 { // record from set, with optional field
42 recordOper_tset x1,
43 recordOper_tset x2 optional
44 };
45type record recordOper_myrec6 { // record from set of, with optional field
46 recordOper_tsetof x1,
47 recordOper_tsetof x2 optional
48 };
49type record recordOper_myrec7 { // record from union, with optional field
50 recordOper_tunion x1,
51 recordOper_tunion x2 optional
52 };
53type record typedefrecordComp_myrec { // testing complex content
54 recordOper_trecord x1,
55 recordOper_trecof x2,
56 recordOper_tset x3,
57 recordOper_tsetof x4 optional,
58 recordOper_tunion x5,
59 integer x6[3]
60};
61type record recordOper_myrec8{
62 integer f1 optional,
63 charstring f2 optional
64 };
65type record recordOper_myrec9 { // test for the assignment of optional fields
66 integer f1 optional,
67 integer f2 optional
68};
69// *************** Constanst ***********************
70const recordOper_trecord recordOper_temp1:={ x1:=omit, x2:=3.4 };
71const recordOper_trecof recordOper_temp2:={ 'AF12'O };
72const recordOper_tset recordOper_temp3:={ x1:=234, x2:=1.9};
73const recordOper_tsetof recordOper_temp4:={"f","8"};
74const recordOper_tunion recordOper_temp5:={ x2:=1.3 };
75const recordOper_myrec1 recordOper_const1:={ //record with basic types
76x1:=1,
77x2:=1.2,
78x3:=xx2 };
79const recordOper_myrec2 recordOper_const2:={ //record with basic types, with optional field
80x1:=1,
81x2:=1.2,
82x3:=xx2,
83x4:=2 };
84const recordOper_myrec2 recordOper_const3:={ //record with basic types, with omited field
85x1:=1,
86x2:=1.2,
87x3:=xx2,
88x4:=omit };
89const recordOper_myrec3 recordOper_const4:={ //record from record
90 x1:={ x1:=1, x2:=1.2 },
91 x2:=recordOper_temp1
92};
93const recordOper_myrec3 recordOper_const5:={ //record from record, with omited field
94 x1:={ x1:=1, x2:=1.2 },
95 x2:=omit
96};
97const recordOper_myrec4 recordOper_const6:={ //record from record of
98 x1:={ '12AB'O, 'CD12'O },
99 x2:=recordOper_temp2
100};
101const recordOper_myrec4 recordOper_const7:={ //record from record of, with omited field
102 x1:={ '12AB'O, 'CD12'O },
103 x2:=omit
104};
105const recordOper_myrec5 recordOper_const8:={ //record from set
106 x1:={ x1:=2, x2:=1.3},
107 x2:=recordOper_temp3
108};
109const recordOper_myrec5 recordOper_const9:={ //record from set, with omited field
110 x1:={ x1:=2, x2:=1.3},
111 x2:=omit
112};
113const recordOper_myrec6 recordOper_const10:={ //record from set of
114 x1:={"a","b"},
115 x2:=recordOper_temp4 //{"f","8"},
116};
117const recordOper_myrec6 recordOper_const11:={ //record from set of, with omited field
118 x1:={"a","b"},
119 x2:=omit
120};
121const recordOper_myrec7 recordOper_const12:={ //record from union
122 x1:={ x1 :=3 },
123 x2:=recordOper_temp5 //{ x2:=1.3 }
124};
125const recordOper_myrec7 recordOper_const13:={ //record from union, with omited field
126 x1:={ x1 :=3 },
127 x2:=omit
128};
129const typedefrecordComp_myrec recordOper_const14 := { // complex record
130 x1 := { x1:=omit, x2:=3.4 },
131 x2 := { 'AF12'O },
132 x3 := { x1:=234, x2:=1.9},
133 x4 := {"f","8"},
134 x5 := { x2:=1.3 },
135 x6 := {1,2,3}
136}
137
138testcase recordAssign() runs on recordOper_mycomp{
139var recordOper_myrec1 x1:={ //record with basic types
140x1:=1,
141x2:=1.2,
142x3:=xx2 };
143var recordOper_myrec1 x2;
144 x2:={ x1:=1, x2:=1.2, x3:=xx2 };
145var recordOper_myrec1 x3 := {};
146if (x1.x1==1) {setverdict(pass);} //at declaration
147 else {setverdict(fail);}
148if (x1.x2==1.2) {setverdict(pass);}
149 else {setverdict(fail);}
150if (x1.x3==xx2) {setverdict(pass);}
151 else {setverdict(fail);}
152if (x2.x1==1) {setverdict(pass);} //later
153 else {setverdict(fail);}
154if (x2.x2==1.2) {setverdict(pass);}
155 else {setverdict(fail);}
156if (x2.x3==xx2) {setverdict(pass);}
157 else {setverdict(fail);}
158}
159
160// test some incomplete assignment cases.
161testcase recordAssignIncomplete() runs on recordOper_mycomp{
162var recordOper_myrec1 x1:={ x1:=1, x2:=1.2};
163 if(x1.x1==1) {setverdict(pass);}
164 else {setverdict(fail);}
165 if(x1.x2==1.2) {setverdict(pass);}
166 else {setverdict(fail);}
167 if(not(isbound(x1.x3))) {setverdict(pass);}
168 else {setverdict(fail);}
169
170x1 := {2, -, -};
171 if(x1.x1==2) {setverdict(pass);}
172 else {setverdict(fail);}
173 if(x1.x2==1.2) {setverdict(pass);}
174 else {setverdict(fail);}
175 if(not(isbound(x1.x3))) {setverdict(pass);}
176 else {setverdict(fail);}
177
178x1:= { x1 := -, x2:=2.2, x3 := -};
179 if(x1.x1==2) {setverdict(pass);}
180 else {setverdict(fail);}
181 if(x1.x2==2.2) {setverdict(pass);}
182 else {setverdict(fail);}
183 if(not(isbound(x1.x3))) {setverdict(pass);}
184 else {setverdict(fail);}
185
186x1:= { x2:=3.2};
187 if(x1.x1==2) {setverdict(pass);}
188 else {setverdict(fail);}
189 if(x1.x2==3.2) {setverdict(pass);}
190 else {setverdict(fail);}
191 if(not(isbound(x1.x3))) {setverdict(pass);}
192 else {setverdict(fail);}
193}
194
195testcase recordAssignOpt() runs on recordOper_mycomp{
196var integer inttemp:=2;
197var recordOper_myrec2 x1:={ //record with basic types, with optional field
198x1:=1,
199x2:=1.2,
200x3:=xx2,
201x4:=inttemp}; //2
202var recordOper_myrec2 x2:={ //record with basic types, with omited field
203x1:=1,
204x2:=1.2,
205x3:=xx2,
206x4:=omit };
207var recordOper_myrec2 x3, x4;
208x3:={ //record with basic types, with optional field
209x1:=1,
210x2:=1.2,
211x3:=xx2,
212x4:=inttemp }; //2
213x4:={ //record with basic types, with omited field
214x1:=1,
215x2:=1.2,
216x3:=xx2,
217x4:=omit };
218//at declaration, with optional field
219if (x1.x1==1) {setverdict(pass);}
220 else {setverdict(fail);}
221if (x1.x2==1.2) {setverdict(pass);}
222 else {setverdict(fail);}
223if (x1.x3==xx2) {setverdict(pass);}
224 else {setverdict(fail);}
225if (x1.x4==2) {setverdict(pass);}
226 else {setverdict(fail);}
227//at declaration, with omited field
228if (x2.x1==1) {setverdict(pass);}
229 else {setverdict(fail);}
230if (x2.x2==1.2) {setverdict(pass);}
231 else {setverdict(fail);}
232if (x2.x3==xx2) {setverdict(pass);}
233 else {setverdict(fail);}
234if (not(ispresent(x2.x4))) {setverdict(pass);}
235 else {setverdict(fail);}
236//later, with optional field
237if (x3.x1==1) {setverdict(pass);}
238 else {setverdict(fail);}
239if (x3.x2==1.2) {setverdict(pass);}
240 else {setverdict(fail);}
241if (x3.x3==xx2) {setverdict(pass);}
242 else {setverdict(fail);}
243if (x3.x4==2) {setverdict(pass);}
244 else {setverdict(fail);}
245//later, with optional field
246if (x4.x1==1) {setverdict(pass);}
247 else {setverdict(fail);}
248if (x4.x2==1.2) {setverdict(pass);}
249 else {setverdict(fail);}
250if (x4.x3==xx2) {setverdict(pass);}
251 else {setverdict(fail);}
252if (not(ispresent(x4.x4))) {setverdict(pass);}
253 else {setverdict(fail);}
254}
255
256testcase recordAssignRec() runs on recordOper_mycomp{
257var recordOper_trecord temp1:={ x1:=omit, x2:=3.4 };
258var recordOper_myrec3 x1:={ //record from record
259 x1:={ x1:=1, x2:=1.2 },
260 x2:=temp1
261};
262var recordOper_myrec3 x2:={ //record from record, with omited field
263 x1:={ x1:=1, x2:=1.2 },
264 x2:=omit
265};
266var recordOper_myrec3 x3,x4;
267x3:={ //record from record
268 x1:={ x1:=1, x2:=1.2 },
269 x2:=temp1
270};
271x4:={ //record from record, with omited field
272 x1:={ x1:=1, x2:=1.2 },
273 x2:=omit
274};
275if (x1.x1.x1==1) {setverdict(pass);} //at declaration
276 else {setverdict(fail);}
277if (x1.x1.x2==1.2) {setverdict(pass);}
278 else {setverdict(fail);}
279if (x1.x2==temp1) {setverdict(pass);}
280 else {setverdict(fail);}
281if (x2.x1.x1==1) {setverdict(pass);} //at declaration, omit
282 else {setverdict(fail);}
283if (x2.x1.x2==1.2) {setverdict(pass);}
284 else {setverdict(fail);}
285if (not(ispresent(x2.x2))) {setverdict(pass);}
286 else {setverdict(fail);}
287if (x3.x1.x1==1) {setverdict(pass);} //later
288 else {setverdict(fail);}
289if (x3.x1.x2==1.2) {setverdict(pass);}
290 else {setverdict(fail);}
291if (x3.x2==temp1) {setverdict(pass);}
292 else {setverdict(fail);}
293if (x4.x1.x1==1) {setverdict(pass);} //later, omit
294 else {setverdict(fail);}
295if (x4.x1.x2==1.2) {setverdict(pass);}
296 else {setverdict(fail);}
297if (not(ispresent(x4.x2))) {setverdict(pass);}
298 else {setverdict(fail);}
299}
300
301testcase recordAssignRecof() runs on recordOper_mycomp{
302var recordOper_trecof temp2:={'AF12'O};
303var recordOper_myrec4 x1:={ //record from record of
304 x1:={ '12AB'O, 'CD12'O },
305 x2:=temp2
306};
307var recordOper_myrec4 x2:={ //record from record of, with omited field
308 x1:={ '12AB'O, 'CD12'O },
309 x2:=omit
310};
311var recordOper_myrec4 x3,x4
312x3:={ //record from record of
313 x1:={ '12AB'O, 'CD12'O },
314 x2:=temp2
315};
316x4:={ //record from record of, with omited field
317 x1:={ '12AB'O, 'CD12'O },
318 x2:=omit
319};
320if (x1.x1[0]=='12AB'O) {setverdict(pass);} //at declaration
321 else {setverdict(fail);}
322if (x1.x1[1]=='CD12'O) {setverdict(pass);}
323 else {setverdict(fail);}
324if (x1.x2==temp2) {setverdict(pass);}
325 else {setverdict(fail);}
326if (x2.x1[0]=='12AB'O) {setverdict(pass);} //at declaration, omit
327 else {setverdict(fail);}
328if (x2.x1[1]=='CD12'O) {setverdict(pass);}
329 else {setverdict(fail);}
330if (not(ispresent(x2.x2))) {setverdict(pass);}
331 else {setverdict(fail);}
332if (x3.x1[0]=='12AB'O) {setverdict(pass);} //later
333 else {setverdict(fail);}
334if (x3.x1[1]=='CD12'O) {setverdict(pass);}
335 else {setverdict(fail);}
336if (x3.x2==temp2) {setverdict(pass);}
337 else {setverdict(fail);}
338if (x4.x1[0]=='12AB'O) {setverdict(pass);} //later, omit
339 else {setverdict(fail);}
340if (x4.x1[1]=='CD12'O) {setverdict(pass);}
341 else {setverdict(fail);}
342if (not(ispresent(x4.x2))) {setverdict(pass);}
343 else {setverdict(fail);}
344}
345
346testcase recordAssignSet() runs on recordOper_mycomp{
347var recordOper_tset temp1:={ x1:=2, x2:=omit };
348var recordOper_myrec5 x1:={ //record from set
349 x1:={ x1:=1, x2:=1.2 },
350 x2:=temp1
351};
352var recordOper_myrec5 x2:={ //record from set, with omited field
353 x1:={ x1:=1, x2:=1.2 },
354 x2:=omit
355};
356var recordOper_myrec5 x3,x4;
357x3:={ //record from set
358 x1:={ x1:=1, x2:=1.2 },
359 x2:=temp1
360};
361x4:={ //record from set, with omited field
362 x1:={ x1:=1, x2:=1.2 },
363 x2:=omit
364};
365if (x1.x1.x1==1) {setverdict(pass);} //at declaration
366 else {setverdict(fail);}
367if (x1.x1.x2==1.2) {setverdict(pass);}
368 else {setverdict(fail);}
369if (x1.x2==temp1) {setverdict(pass);}
370 else {setverdict(fail);}
371if (x2.x1.x1==1) {setverdict(pass);} //at declaration, omit
372 else {setverdict(fail);}
373if (x2.x1.x2==1.2) {setverdict(pass);}
374 else {setverdict(fail);}
375if (not(ispresent(x2.x2))) {setverdict(pass);}
376 else {setverdict(fail);}
377if (x3.x1.x1==1) {setverdict(pass);} //later
378 else {setverdict(fail);}
379if (x3.x1.x2==1.2) {setverdict(pass);}
380 else {setverdict(fail);}
381if (x3.x2==temp1) {setverdict(pass);}
382 else {setverdict(fail);}
383if (x4.x1.x1==1) {setverdict(pass);} //later, omit
384 else {setverdict(fail);}
385if (x4.x1.x2==1.2) {setverdict(pass);}
386 else {setverdict(fail);}
387if (not(ispresent(x4.x2))) {setverdict(pass);}
388 else {setverdict(fail);}
389}
390
391testcase recordAssignSetof() runs on recordOper_mycomp{
392var recordOper_tsetof temp2:={"a","7"};
393var recordOper_myrec6 x1:={ //record from set of
394 x1:={ "1", "a" },
395 x2:=temp2
396};
397var recordOper_myrec6 x2:={ //record from set of, with omited field
398 x1:={ "1", "a" },
399 x2:=omit
400};
401var recordOper_myrec6 x3,x4
402x3:={ //record from set of
403 x1:={ "1", "a" },
404 x2:=temp2
405};
406x4:={ //record from set of, with omited field
407 x1:={ "1","a" },
408 x2:=omit
409};
410if (x1.x1[0]=="1") {setverdict(pass);} //at declaration
411 else {setverdict(fail);}
412if (x1.x1[1]=="a") {setverdict(pass);}
413 else {setverdict(fail);}
414if (x1.x2==temp2) {setverdict(pass);}
415 else {setverdict(fail);}
416if (x2.x1[0]=="1") {setverdict(pass);} //at declaration, omit
417 else {setverdict(fail);}
418if (x2.x1[1]=="a") {setverdict(pass);}
419 else {setverdict(fail);}
420if (not(ispresent(x2.x2))) {setverdict(pass);}
421 else {setverdict(fail);}
422if (x3.x1[0]=="1") {setverdict(pass);} //later
423 else {setverdict(fail);}
424if (x3.x1[1]=="a") {setverdict(pass);}
425 else {setverdict(fail);}
426if (x3.x2==temp2) {setverdict(pass);}
427 else {setverdict(fail);}
428if (x4.x1[0]=="1") {setverdict(pass);} //later, omit
429 else {setverdict(fail);}
430if (x4.x1[1]=="a") {setverdict(pass);}
431 else {setverdict(fail);}
432if (not(ispresent(x4.x2))) {setverdict(pass);}
433 else {setverdict(fail);}
434}
435
436testcase recordAssignUnion() runs on recordOper_mycomp{
437var recordOper_tunion temp5 := {x2:=1.3}
438var recordOper_myrec7 x1:={ //record from union
439 x1:={ x1 :=3 },
440 x2:=temp5 //{ x2:=1.3 }
441};
442var recordOper_myrec7 x2:={ //record from union, with omited field
443 x1:={ x1 :=3 },
444 x2:=omit
445};
446var recordOper_myrec7 x3,x4;
447x3:={ //record from union
448 x1:={ x1 :=3 },
449 x2:=temp5 //{ x2:=1.3 }
450};
451x4:={ //record from union, with omited field
452 x1:={ x1 :=3 },
453 x2:=omit
454};
455if (x1.x1.x1==3) {setverdict(pass);} //at declaration
456 else {setverdict(fail);}
457if (ischosen(x1.x1.x1)) {setverdict(pass);}
458 else {setverdict(fail);}
459if (not(ischosen(x1.x1.x2))) {setverdict(pass);}
460 else {setverdict(fail);}
461if (x1.x2==temp5) {setverdict(pass);}
462 else {setverdict(fail);}
463if (x2.x1.x1==3) {setverdict(pass);} //at declaration, omit
464 else {setverdict(fail);}
465if (ischosen(x2.x1.x1)) {setverdict(pass);}
466 else {setverdict(fail);}
467if (not(ischosen(x2.x1.x2))) {setverdict(pass);}
468 else {setverdict(fail);}
469if (not(ispresent(x2.x2))) {setverdict(pass);}
470 else {setverdict(fail);}
471if (x3.x1.x1==3) {setverdict(pass);} //later
472 else {setverdict(fail);}
473if (ischosen(x3.x1.x1)) {setverdict(pass);}
474 else {setverdict(fail);}
475if (not(ischosen(x3.x1.x2))) {setverdict(pass);}
476 else {setverdict(fail);}
477if (x3.x2==temp5) {setverdict(pass);}
478 else {setverdict(fail);}
479if (x4.x1.x1==3) {setverdict(pass);} //later, omit
480 else {setverdict(fail);}
481if (ischosen(x4.x1.x1)) {setverdict(pass);}
482 else {setverdict(fail);}
483if (not(ischosen(x4.x1.x2))) {setverdict(pass);}
484 else {setverdict(fail);}
485if (not(ispresent(x4.x2))) {setverdict(pass);}
486 else {setverdict(fail);}
487}
488
489testcase recordAssignElem() runs on recordOper_mycomp{
490var recordOper_myrec1 x1:={ //record with basic types
491x1:=1,
492x2:=1.2,
493x3:=xx2 };
494x1.x2:=3.4;
495if (x1.x1==1) {setverdict(pass);}
496 else {setverdict(fail);}
497if (x1.x2==3.4) {setverdict(pass);}
498 else {setverdict(fail);}
499if (x1.x3==xx2) {setverdict(pass);}
500 else {setverdict(fail);}
501}
502
503
504testcase recordAssignElemOpt() runs on recordOper_mycomp{
505var integer inttemp:=2;
506var recordOper_myrec2 x1:={ //record with basic types
507x1:=1,
508x2:=1.2,
509x3:=xx2,
510x4:=omit } ; //2
511var recordOper_myrec2 x2, x3, x4;
512x2:=x1;
513x3:={x1:=1, x2:=1.2, x3:=xx2, x4:=inttemp };
514x4:=x2;
515x1.x1:=2; //not optional field
516x2.x4:=3; //optional field; omited-> value
517x3.x4:=3; //optional field; value-> value
518x4.x4:=omit; //optional field; value -> omited
519//change not optional field
520if (x1.x1==2) {setverdict(pass);}
521 else {setverdict(fail);}
522if (x1.x2==1.2) {setverdict(pass);}
523 else {setverdict(fail);}
524if (x1.x3==xx2) {setverdict(pass);}
525 else {setverdict(fail);}
526if (not(ispresent(x1.x4))) {setverdict(pass);}
527 else {setverdict(fail);}
528//omited -> value
529if (x2.x1==1) {setverdict(pass);}
530 else {setverdict(fail);}
531if (x2.x2==1.2) {setverdict(pass);}
532 else {setverdict(fail);}
533if (x2.x3==xx2) {setverdict(pass);}
534 else {setverdict(fail);}
535if (x2.x4==3) {setverdict(pass);}
536 else {setverdict(fail);}
537//optional field; value-> value
538if (x3.x1==1) {setverdict(pass);}
539 else {setverdict(fail);}
540if (x3.x2==1.2) {setverdict(pass);}
541 else {setverdict(fail);}
542if (x3.x3==xx2) {setverdict(pass);}
543 else {setverdict(fail);}
544if (x3.x4==3) {setverdict(pass);}
545 else {setverdict(fail);}
546//optional field; value -> omited
547if (x4.x1==1) {setverdict(pass);}
548 else {setverdict(fail);}
549if (x4.x2==1.2) {setverdict(pass);}
550 else {setverdict(fail);}
551if (x4.x3==xx2) {setverdict(pass);}
552 else {setverdict(fail);}
553if (not(ispresent(x4.x4))) {setverdict(pass);}
554 else {setverdict(fail);}
555}
556
557testcase recordAssignElemRec() runs on recordOper_mycomp{
558var recordOper_trecord temp1:={ x1:=omit, x2:=3.4 };
559var recordOper_myrec3 x1;
560x1:={ //record from record
561 x1:={ x1:=1, x2:=1.2 },
562 x2:=temp1
563};
564x1.x1.x1:=2;
565//temp1.x1:=3;
566//x1.x2:=temp1;
567if (x1.x1.x1==2) {setverdict(pass);}
568 else {setverdict(fail);}
569if (x1.x1.x2==1.2) {setverdict(pass);}
570 else {setverdict(fail);}
571if (x1.x2==temp1) {setverdict(pass);}
572 else {setverdict(fail);}
573}
574
575
576testcase recordAssignElemRecof() runs on recordOper_mycomp{
577var recordOper_trecof temp2:={'AF12'O};
578var recordOper_myrec4 x1:={ //record from record of
579 x1:={ '12AB'O, 'CD12'O },
580 x2:=temp2
581};
582x1.x1[1]:='34AB'O;
583if (x1.x1[0]=='12AB'O) {setverdict(pass);}
584 else {setverdict(fail);}
585if (x1.x1[1]=='34AB'O) {setverdict(pass);}
586 else {setverdict(fail);}
587if (x1.x2==temp2) {setverdict(pass);}
588 else {setverdict(fail);}
589}
590
591testcase recordAssignElemSet() runs on recordOper_mycomp{
592var recordOper_tset temp1:={ x1:=2, x2:=omit };
593var recordOper_myrec5 x1:={ //record from set
594 x1:={ x1:=1, x2:=1.2 },
595 x2:=temp1
596};
597x1.x1.x2:=3.4;
598if (x1.x1.x1==1) {setverdict(pass);}
599 else {setverdict(fail);}
600if (x1.x1.x2==3.4) {setverdict(pass);}
601 else {setverdict(fail);}
602if (x1.x2==temp1) {setverdict(pass);}
603 else {setverdict(fail);}
604}
605
606testcase recordAssignElemSetof() runs on recordOper_mycomp{
607var recordOper_tsetof temp2:={"a","7"};
608var recordOper_myrec6 x1:={ //record from set of
609 x1:={ "1", "a" },
610 x2:=temp2
611};
612x1.x1[0]:="h";
613if (x1.x1[0]=="h") {setverdict(pass);}
614 else {setverdict(fail);}
615if (x1.x1[1]=="a") {setverdict(pass);}
616 else {setverdict(fail);}
617if (x1.x2==temp2) {setverdict(pass);}
618 else {setverdict(fail);}
619}
620
621testcase recordAssignElemUnion() runs on recordOper_mycomp{
622var recordOper_tunion temp5 := {x2:=1.3}
623var recordOper_myrec7 x1:={ //record from union
624 x1:={ x1 :=3 },
625 x2:=temp5 //{ x2:=1.3 }
626};
627x1.x1.x2:=3.4;
628if (x1.x1.x2==3.4) {setverdict(pass);}
629 else {setverdict(fail);}
630if (ischosen(x1.x1.x2)) {setverdict(pass);}
631 else {setverdict(fail);}
632if (not(ischosen(x1.x1.x1))) {setverdict(pass);}
633 else {setverdict(fail);}
634if (x1.x2==temp5) {setverdict(pass);}
635 else {setverdict(fail);}
636}
637
638testcase recordSizeof() runs on recordOper_mycomp{
639var integer inttemp:=2;
640var recordOper_myrec2 x1:={ //record with basic types, with optional field
641x1:=1,
642x2:=1.2,
643x3:=xx2,
644x4:=inttemp}; //2
645var recordOper_myrec2 x2:={ //record with basic types, with omited field
646x1:=1,
647x2:=1.2,
648x3:=xx2,
649x4:=omit };
650var recordOper_myrec2 x3, x4;
651x3:={ //record with basic types, with optional field
652x1:=1,
653x2:=1.2,
654x3:=xx2,
655x4:=inttemp }; //2
656x4:={ //record with basic types, with omited field
657x1:=1,
658x2:=1.2,
659x3:=xx2,
660x4:=omit };
661var recordOper_myrec4 x5;
662x5.x1 := { '12AB'O, '12AB'O};
663x5.x2 := { '12AB'O, '12AB'O, '12AB'O};
664if (sizeof(x1)==4) {setverdict(pass);} //at declaration, with optional field
665 else {setverdict(fail);}
666if (sizeof(x2)==3) {setverdict(pass);} //at declaration, with omited field
667 else {setverdict(fail);}
668if (sizeof(x3)==4) {setverdict(pass);} //later, with optional field
669 else {setverdict(fail);}
670if (sizeof(x4)==3) {setverdict(pass);} //testcase, with optional field
671 else {setverdict(fail);}
672if (sizeof(x5.x1)==2 and sizeof(x5.x2) == 3) {setverdict(pass);} //testcase, with optional field
673 else {setverdict(fail);}
674}
675
676testcase recordConst() runs on recordOper_mycomp{
677const recordOper_myrec1 const1:={ //record with basic types
678x1:=1,
679x2:=1.2,
680x3:=xx2 };
681if (recordOper_const1.x1==1) {setverdict(pass);} //definition part
682 else {setverdict(fail);}
683if (recordOper_const1.x2==1.2) {setverdict(pass);}
684 else {setverdict(fail);}
685if (recordOper_const1.x3==xx2) {setverdict(pass);}
686 else {setverdict(fail);}
687if (const1.x1==1) {setverdict(pass);} //testcase
688 else {setverdict(fail);}
689if (const1.x2==1.2) {setverdict(pass);}
690 else {setverdict(fail);}
691if (const1.x3==xx2) {setverdict(pass);}
692 else {setverdict(fail);}
693}
694
695testcase recordConstOpt() runs on recordOper_mycomp{
696const recordOper_myrec2 const2:={ //record with basic types, with optional field
697x1:=1,
698x2:=1.2,
699x3:=xx2,
700x4:=2 };
701const recordOper_myrec2 const3:={ //record with basic types, with omited field
702x1:=1,
703x2:=1.2,
704x3:=xx2,
705x4:=omit };
706//definition part, with optional field
707if (recordOper_const2.x1==1) {setverdict(pass);}
708 else {setverdict(fail);}
709if (recordOper_const2.x2==1.2) {setverdict(pass);}
710 else {setverdict(fail);}
711if (recordOper_const2.x3==xx2) {setverdict(pass);}
712 else {setverdict(fail);}
713if (recordOper_const2.x4==2) {setverdict(pass);}
714 else {setverdict(fail);}
715//definition part, with omited field
716if (recordOper_const3.x1==1) {setverdict(pass);}
717 else {setverdict(fail);}
718if (recordOper_const3.x2==1.2) {setverdict(pass);}
719 else {setverdict(fail);}
720if (recordOper_const3.x3==xx2) {setverdict(pass);}
721 else {setverdict(fail);}
722if (not(ispresent(recordOper_const3.x4))) {setverdict(pass);}
723 else {setverdict(fail);}
724//testcase, with optional field
725if (const2.x1==1) {setverdict(pass);}
726 else {setverdict(fail);}
727if (const2.x2==1.2) {setverdict(pass);}
728 else {setverdict(fail);}
729if (const2.x3==xx2) {setverdict(pass);}
730 else {setverdict(fail);}
731if (const2.x4==2) {setverdict(pass);}
732 else {setverdict(fail);}
733//testcase, with omited field
734if (const3.x1==1) {setverdict(pass);}
735 else {setverdict(fail);}
736if (const3.x2==1.2) {setverdict(pass);}
737 else {setverdict(fail);}
738if (const3.x3==xx2) {setverdict(pass);}
739 else {setverdict(fail);}
740if (not(ispresent(const3.x4))) {setverdict(pass);}
741 else {setverdict(fail);}
742}
743
744testcase recordConstRec() runs on recordOper_mycomp{
745const recordOper_myrec3 const4:={ //record from record
746 x1:={ x1:=1, x2:=1.2 },
747 x2:=recordOper_temp1
748};
749const recordOper_myrec3 const5:={ //record from record, with omited field
750 x1:={ x1:=1, x2:=1.2 },
751 x2:=omit
752};
753if (recordOper_const4.x1.x1==1) {setverdict(pass);} //definition part
754 else {setverdict(fail);}
755if (recordOper_const4.x1.x2==1.2) {setverdict(pass);}
756 else {setverdict(fail);}
757if (recordOper_const4.x2==recordOper_temp1) {setverdict(pass);}
758 else {setverdict(fail);}
759if (recordOper_const5.x1.x1==1) {setverdict(pass);} //definition part, omit
760 else {setverdict(fail);}
761if (recordOper_const5.x1.x2==1.2) {setverdict(pass);}
762 else {setverdict(fail);}
763if (not(ispresent(recordOper_const5.x2))) {setverdict(pass);}
764 else {setverdict(fail);}
765if (const4.x1.x1==1) {setverdict(pass);} //testcase
766 else {setverdict(fail);}
767if (const4.x1.x2==1.2) {setverdict(pass);}
768 else {setverdict(fail);}
769if (const4.x2==recordOper_temp1) {setverdict(pass);}
770 else {setverdict(fail);}
771if (const5.x1.x1==1) {setverdict(pass);} //testcase, omit
772 else {setverdict(fail);}
773if (const5.x1.x2==1.2) {setverdict(pass);}
774 else {setverdict(fail);}
775if (not(ispresent(const5.x2))) {setverdict(pass);}
776 else {setverdict(fail);}
777}
778
779testcase recordConstRecof() runs on recordOper_mycomp{
780const recordOper_myrec4 const6:={ //record from record of
781 x1:={ '12AB'O, 'CD12'O },
782 x2:=recordOper_temp2
783};
784const recordOper_myrec4 const7:={ //record from record of, with omited field
785 x1:={ '12AB'O, 'CD12'O },
786 x2:=omit
787};
788if (recordOper_const6.x1[0]=='12AB'O) {setverdict(pass);} //definition part
789 else {setverdict(fail);}
790if (recordOper_const6.x1[1]=='CD12'O) {setverdict(pass);}
791 else {setverdict(fail);}
792if (recordOper_const6.x2==recordOper_temp2) {setverdict(pass);}
793 else {setverdict(fail);}
794if (recordOper_const7.x1[0]=='12AB'O) {setverdict(pass);} //definition part, omit
795 else {setverdict(fail);}
796if (recordOper_const7.x1[1]=='CD12'O) {setverdict(pass);}
797 else {setverdict(fail);}
798if (not(ispresent(recordOper_const7.x2))) {setverdict(pass);}
799 else {setverdict(fail);}
800if (const6.x1[0]=='12AB'O) {setverdict(pass);} //testcase
801 else {setverdict(fail);}
802if (const6.x1[1]=='CD12'O) {setverdict(pass);}
803 else {setverdict(fail);}
804if (const6.x2==recordOper_temp2) {setverdict(pass);}
805 else {setverdict(fail);}
806if (const7.x1[0]=='12AB'O) {setverdict(pass);} //testcase, omit
807 else {setverdict(fail);}
808if (const7.x1[1]=='CD12'O) {setverdict(pass);}
809 else {setverdict(fail);}
810if (not(ispresent(const7.x2))) {setverdict(pass);}
811 else {setverdict(fail);}
812}
813
814testcase recordConstSet() runs on recordOper_mycomp{
815const recordOper_myrec5 const8:={ //record from set
816 x1:={ x1:=2, x2:=1.3},
817 x2:=recordOper_temp3
818};
819const recordOper_myrec5 const9:={ //record from set, with omited field
820 x1:={ x1:=2, x2:=omit},
821 x2:=omit
822};
823if (recordOper_const8.x1.x1==2) {setverdict(pass);} //definition part
824 else {setverdict(fail);}
825if (recordOper_const8.x1.x2==1.3) {setverdict(pass);}
826 else {setverdict(fail);}
827if (recordOper_const8.x2==recordOper_temp3) {setverdict(pass);}
828 else {setverdict(fail);}
829if (recordOper_const9.x1.x1==2) {setverdict(pass);} //definition part, omit
830 else {setverdict(fail);}
831if (recordOper_const9.x1.x2==1.3) {setverdict(pass);}
832 else {setverdict(fail);}
833if (not(ispresent(recordOper_const9.x2))) {setverdict(pass);}
834 else {setverdict(fail);}
835if (const8.x1.x1==2) {setverdict(pass);} //testcase
836 else {setverdict(fail);}
837if (const8.x1.x2==1.3) {setverdict(pass);}
838 else {setverdict(fail);}
839if (const8.x2==recordOper_temp3) {setverdict(pass);}
840 else {setverdict(fail);}
841if (const9.x1.x1==2) {setverdict(pass);} //testcase, omit
842 else {setverdict(fail);}
843if (not(ispresent(const9.x1.x2))) {setverdict(pass);}
844 else {setverdict(fail);}
845if (not(ispresent(const9.x2))) {setverdict(pass);}
846 else {setverdict(fail);}
847}
848
849testcase recordConstSetof() runs on recordOper_mycomp{
850const recordOper_myrec6 const10:={ //record from set of
851 x1:={"a","b"},
852 x2:=recordOper_temp4 //{"f","8"},
853};
854const recordOper_myrec6 const11:={ //record from set of, with omited field
855 x1:={"a","b"},
856 x2:=omit
857};
858if (recordOper_const10.x1[0]=="a") {setverdict(pass);} //definition part
859 else {setverdict(fail);}
860if (recordOper_const10.x1[1]=="b") {setverdict(pass);}
861 else {setverdict(fail);}
862if (recordOper_const10.x2==recordOper_temp4) {setverdict(pass);}
863 else {setverdict(fail);}
864if (recordOper_const11.x1[0]=="a") {setverdict(pass);} //definition part, omit
865 else {setverdict(fail);}
866if (recordOper_const11.x1[1]=="b") {setverdict(pass);}
867 else {setverdict(fail);}
868if (not(ispresent(recordOper_const11.x2))) {setverdict(pass);}
869 else {setverdict(fail);}
870if (const10.x1[0]=="a") {setverdict(pass);} //testcase
871 else {setverdict(fail);}
872if (const10.x1[1]=="b") {setverdict(pass);}
873 else {setverdict(fail);}
874if (const10.x2==recordOper_temp4) {setverdict(pass);}
875 else {setverdict(fail);}
876if (const11.x1[0]=="a") {setverdict(pass);} //testcase, omit
877 else {setverdict(fail);}
878if (const11.x1[1]=="b") {setverdict(pass);}
879 else {setverdict(fail);}
880if (not(ispresent(const11.x2))) {setverdict(pass);}
881 else {setverdict(fail);}
882}
883
884testcase recordConstUnion() runs on recordOper_mycomp{
885const recordOper_myrec7 const12:={ //record from union
886 x1:={ x1 :=3 },
887 x2:=recordOper_temp5 //{ x2:=1.3 }
888};
889const recordOper_myrec7 const13:={ //record from union, with omited field
890 x1:={ x1 :=3 },
891 x2:=omit
892};
893if (recordOper_const12.x1.x1==3) {setverdict(pass);} //definition part
894 else {setverdict(fail);}
895if (ischosen(recordOper_const12.x1.x1)) {setverdict(pass);}
896 else {setverdict(fail);}
897if (not(ischosen(recordOper_const12.x1.x2))) {setverdict(pass);}
898 else {setverdict(fail);}
899if (recordOper_const12.x2==recordOper_temp5) {setverdict(pass);}
900 else {setverdict(fail);}
901if (recordOper_const13.x1.x1==3) {setverdict(pass);} //definition part, omit
902 else {setverdict(fail);}
903if (ischosen(recordOper_const13.x1.x1)) {setverdict(pass);}
904 else {setverdict(fail);}
905if (not(ischosen(recordOper_const13.x1.x2))) {setverdict(pass);}
906 else {setverdict(fail);}
907if (not(ispresent(recordOper_const13.x2))) {setverdict(pass);}
908 else {setverdict(fail);}
909if (const12.x1.x1==3) {setverdict(pass);} //testcase
910 else {setverdict(fail);}
911if (ischosen(const12.x1.x1)) {setverdict(pass);}
912 else {setverdict(fail);}
913if (not(ischosen(const12.x1.x2))) {setverdict(pass);}
914 else {setverdict(fail);}
915if (const12.x2==recordOper_temp5) {setverdict(pass);}
916 else {setverdict(fail);}
917if (const13.x1.x1==3) {setverdict(pass);} //testcase, omit
918 else {setverdict(fail);}
919if (ischosen(const13.x1.x1)) {setverdict(pass);}
920 else {setverdict(fail);}
921if (not(ischosen(const13.x1.x2))) {setverdict(pass);}
922 else {setverdict(fail);}
923if (not(ispresent(const13.x2))) {setverdict(pass);}
924 else {setverdict(fail);}
925}
926
927testcase recordComp() runs on recordOper_mycomp{
928var recordOper_myrec1 x1,x2,x3; // record with basic types
929x1:={ x1:=1, x2:=1.2, x3:=xx2 };
930x2:={ x1:=1, x2:=1.2, x3:=xx2 };
931x3:={ x1:=1, x2:=1.24, x3:=xx2 }
932if (x1==x2) {setverdict(pass);}
933 else {setverdict(fail);}
934if (not(x1==x3)) {setverdict(pass);}
935 else {setverdict(fail);}
936if (x1!=x3) {setverdict(pass);}
937 else {setverdict(fail);}
938if (not(x1!=x2)) {setverdict(pass);}
939 else {setverdict(fail);}
940}
941
942
943testcase recordCompOpt() runs on recordOper_mycomp{
944var integer inttemp:=2; // record with basic types and optional field
945var recordOper_myrec2 x1,x2,x3;
946x1 :={ x1:=1, x2:=1.2, x3:=xx2, x4:=inttemp }; //inntemp=2
947x2:= { x1:=1, x2:=1.2, x3:=xx2, x4:=omit };
948x3:= { x1:=1, x2:=1.2, x3:=xx2, x4:=omit };
949if (x2==x3) {setverdict(pass);}
950 else {setverdict(fail);}
951if (not(x1==x2)) {setverdict(pass);}
952 else {setverdict(fail);}
953if (x1!=x3) {setverdict(pass);}
954 else {setverdict(fail);}
955if (not(x2!=x3)) {setverdict(pass);}
956 else {setverdict(fail);}
957}
958
959testcase recordCompOptField() runs on recordOper_mycomp
960{
961 const recordOper_trecord c1 := { x1 := omit, x2 := 0.0 };
962 const recordOper_trecord c2 := { x1 := 1, x2 := 0.0 };
963 const integer ci := 1;
964 var recordOper_trecord v := { x1 := omit };
965 var integer i := 1;
966 if (c1.x1 == omit and c1.x1 != 1 and /*c1.x1 != i and*/ c1.x1 != ci and c1.x1 == c1.x1 and
967 omit == c1.x1 and 1 != c1.x1 and /*i != c1.x1 and*/ ci != c1.x1 and not c1.x1 != c1.x1)
968 { setverdict(pass); }
969 else { setverdict(fail); }
970 if (c2.x1 != omit and c2.x1 == 1 and c2.x1 == i and c2.x1 == ci and c2.x1 == c2.x1 and
971 omit != c2.x1 and 1 == c2.x1 and i == c2.x1 and ci == c2.x1 and not c2.x1 != c2.x1)
972 { setverdict(pass); }
973 else { setverdict(fail); }
974 if (v.x1 == omit and v.x1 != 1 and v.x1 != i and v.x1 == v.x1 and
975 omit == v.x1 and 1 != v.x1 and i != v.x1 and not v.x1 != v.x1)
976 { setverdict(pass); }
977 else { setverdict(fail); }
978 v.x1 := 1;
979 if (v.x1 != omit and v.x1 == 1 and v.x1 == i and v.x1 == v.x1 and
980 omit != v.x1 and 1 == v.x1 and i == v.x1 and not v.x1 != v.x1)
981 { setverdict(pass); }
982 else { setverdict(fail); }
983}
984
985testcase recordCompRec() runs on recordOper_mycomp{
986var recordOper_trecord temp1:={ x1:=omit, x2:=3.4 }; // record with record
987var recordOper_myrec3 x1,x2,x3;
988x1 :={
989 x1:={ x1:=1, x2:=1.2 },
990 x2:=temp1
991};
992x2 :={
993 x1:={ x1:=1, x2:=1.2 },
994 x2:=temp1
995};
996x3 :={
997 x1:={ x1:=2, x2:=1.2 },
998 x2:=temp1
999};
1000if (x1==x2) {setverdict(pass);}
1001 else {setverdict(fail);}
1002if (not(x1==x3)) {setverdict(pass);}
1003 else {setverdict(fail);}
1004if (x1!=x3) {setverdict(pass);}
1005 else {setverdict(fail);}
1006if (not(x1!=x2)) {setverdict(pass);}
1007 else {setverdict(fail);}
1008}
1009
1010
1011testcase recordCompRecof() runs on recordOper_mycomp{
1012var recordOper_trecof temp2:={'AF12'O};
1013var recordOper_myrec4 x1,x2,x3;
1014x1:={ //record from record of
1015 x1:={ '12AB'O, 'CD12'O },
1016 x2:=temp2
1017};
1018x2:={ //record from record of
1019 x1:={ '12AB'O, 'CD12'O },
1020 x2:=temp2
1021};
1022x3:={ //record from record of
1023 x1:={ '12AB'O },
1024 x2:=temp2
1025};
1026if (x1==x2) {setverdict(pass);}
1027 else {setverdict(fail);}
1028if (not(x1==x3)) {setverdict(pass);}
1029 else {setverdict(fail);}
1030if (x2!=x3) {setverdict(pass);}
1031 else {setverdict(fail);}
1032if (not(x1!=x2)) {setverdict(pass);}
1033 else {setverdict(fail);}
1034}
1035
1036testcase recordCompSet() runs on recordOper_mycomp{
1037var recordOper_tset temp1:={ x1:=2, x2:=omit };
1038var recordOper_myrec5 x1,x2,x3; //record from set
1039x1:={
1040 x1:={ x1:=1, x2:=1.2 },
1041 x2:=temp1
1042};
1043x2:={
1044 x1:={ x1:=1, x2:=1.2 },
1045 x2:=temp1
1046};
1047x3:={
1048 x1:={ x1:=4, x2:=1.2 },
1049 x2:=temp1
1050};
1051if (x1==x2) {setverdict(pass);}
1052 else {setverdict(fail);}
1053if (not(x2==x3)) {setverdict(pass);}
1054 else {setverdict(fail);}
1055if (x1!=x3) {setverdict(pass);}
1056 else {setverdict(fail);}
1057if (not(x1!=x2)) {setverdict(pass);}
1058 else {setverdict(fail);}
1059}
1060
1061testcase recordCompSetof() runs on recordOper_mycomp{
1062var recordOper_tsetof temp2:={"a","7"};
1063var recordOper_myrec6 x1,x2,x3; //record from set of
1064x1:={
1065 x1:={ "1", "a" },
1066 x2:=temp2
1067};
1068x2:={
1069 x1:={ "1", "a" },
1070 x2:=temp2
1071};
1072x3:={
1073 x1:={ "1", "a", "k" },
1074 x2:=temp2
1075};
1076if (x1==x2) {setverdict(pass);}
1077 else {setverdict(fail);}
1078if (not(x2==x3)) {setverdict(pass);}
1079 else {setverdict(fail);}
1080if (x1!=x3) {setverdict(pass);}
1081 else {setverdict(fail);}
1082if (not(x1!=x2)) {setverdict(pass);}
1083 else {setverdict(fail);}
1084}
1085
1086testcase recordCompUnion() runs on recordOper_mycomp{
1087var recordOper_tunion temp5 := {x2:=1.3}; //record from union
1088var recordOper_myrec7 x1,x2,x3;
1089x1:={
1090 x1:={ x1 :=3 },
1091 x2:=temp5 //{ x2:=1.3 }
1092};
1093x2:={
1094 x1:={ x1 :=3 },
1095 x2:=temp5 //{ x2:=1.3 }
1096};
1097x3:={
1098 x1:={ x2 :=3.9 },
1099 x2:=temp5 //{ x2:=1.3 }
1100};
1101if (x1==x2) {setverdict(pass);}
1102 else {setverdict(fail);}
1103if (not(x1==x3)) {setverdict(pass);}
1104 else {setverdict(fail);}
1105if (x2!=x3) {setverdict(pass);}
1106 else {setverdict(fail);}
1107if (not(x1!=x2)) {setverdict(pass);}
1108 else {setverdict(fail);}
1109}
1110
1111// Example from CR 5262. No need to list all fields explicitly in the further
1112// restricted type: `type myrecr1 myrecr2 ({ "", "" }, { "", "" })'.
1113type record myrec1 {
1114 integer f1 (0..255),
1115 charstring f2,
1116 charstring f3 optional
1117}
1118type myrec1 myrec2 ({1, "", ""}, {2, "", ""}, {f1 := 3, f2 := "", f3 := omit})
1119type record MyRecordTypeWithSubtypedFields {
1120 integer field1 (1..100),
1121 charstring field2 length(2..255)
1122}
1123type myrec1 myrec3 (myrec2, {1, "", ""})
1124
1125const myrec2 c_myrec1 := {1, "", ""}
1126
1127template myrec2 t_myrec1 := c_myrec1
1128
1129function f_rec1() return MyRecordTypeWithSubtypedFields {
1130 return { 2, "aaa" }
1131}
1132
1133testcase recordSubtypes() runs on recordOper_mycomp {
1134 var template MyRecordTypeWithSubtypedFields vt_myrec1 := {100, "hello"}
1135 var MyRecordTypeWithSubtypedFields v_myrec1 := {field1 := 100, field2 := "hello"}
1136 var myrec2 v_myrec2 := valueof(modifies t_myrec1 := {f1 := 2})
1137 if (match(valueof(v_myrec1), vt_myrec1)) { setverdict(pass) }
1138 else { setverdict(fail) }
1139 if ({ 2, "aaa" } == f_rec1() and f_rec1() == { 2, "aaa" }) { setverdict(pass) }
1140 else { setverdict(fail) }
1141 // FATAL_ERROR() with R8B: `if (valueof(MyRecordTypeWithSubtypedFields:{ 1, "hello" }) == valueof(v_myrec1)) { setverdict(pass) }'.
1142}
1143
1144testcase recordIsvalue() runs on recordOper_mycomp{
1145 var recordOper_empty v1;
1146 var recordOper_trecord vs2_def;
1147 var recordOper_trecord v2;
1148 v2.x1 := 42;
1149
1150 if ( isvalue(v1) ) { setverdict(fail); } else { setverdict(pass); };
1151 if ( isvalue(vs2_def) ) { setverdict(fail); } else { setverdict(pass); };
1152 if ( isvalue(v2) ) { setverdict(fail); } else { setverdict(pass); };
1153
1154 var recordOper_trecord vs2_part := { -, 1.0 };
1155 if ( isvalue(vs2_part) ) { setverdict(fail); } else { setverdict(pass); };
1156 vs2_part.x1 := omit;
1157 if ( isvalue(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };
1158
1159 var recordOper_trecord vs2_om := { omit, - };
1160 if ( isvalue(vs2_om) ) { setverdict(fail); } else { setverdict(pass); };
1161 vs2_om.x2 := 33.0;
1162 if ( isvalue(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
1163}
1164
1165testcase recordIsbound() runs on recordOper_mycomp{
1166 var recordOper_empty v1;
1167 var recordOper_trecord vs2_def;
1168 var recordOper_trecord v2;
1169 v2.x1 := 42;
1170
1171 if ( isbound(v1) ) { setverdict(fail); } else { setverdict(pass); };
1172 if ( isbound(vs2_def) ) { setverdict(fail); } else { setverdict(pass); };
1173 if ( isbound(vs2_def.x1) ) { setverdict(fail); } else { setverdict(pass); };
1174 if ( isbound(vs2_def.x2) ) { setverdict(fail); } else { setverdict(pass); };
1175 if ( isbound(v2) ) { setverdict(pass); } else { setverdict(fail); };
1176
1177 var recordOper_trecord vs2_part := { -, 1.0 };
1178 if ( isbound(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };
1179 vs2_part.x1 := omit;
1180 if ( isbound(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };
1181
1182 var recordOper_trecord vs2_om := { omit, - };
1183 if ( isbound(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
1184 vs2_om.x2 := 33.0;
1185 if ( isbound(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
1186}
1187
1188type set AllRec {
1189 recordOper_myrec8 r1,
1190 recordOper_myrec8 r2 optional
1191}
1192template recordOper_myrec8 t_MyRec := { f1 := *, f2 := * };
1193const recordOper_myrec8 c1_MyRec := { f1 := 5, f2 := omit };
1194const recordOper_myrec8 c2_MyRec := { f1 := omit, f2 := "omit" };
1195const AllRec c_AllRec := { r1 := c1_MyRec, r2 := c2_MyRec }
1196// This function is called from testcase recordIsvalue2
1197function f_isvalue_record(in recordOper_myrec8 p1_MyRec, in recordOper_myrec8 p2_MyRec, in AllRec p_AllRec, in template recordOper_myrec8 pt_MyRec) runs on recordOper_mycomp
1198{
1199 var recordOper_myrec8 v1_MyRec;
1200 var recordOper_myrec8 v2_MyRec;
1201 var template recordOper_myrec8 vt_MyRec;
1202 var AllRec v_AllRec;
1203 template integer ti := 5 ifpresent;
1204 template recordOper_myrec8 rrr1 := { 11, "true" }
1205 template recordOper_myrec8 rrr2 := { 11, "true" } ifpresent;
1206 template recordOper_myrec8 rrr3 := { 11, "true" ifpresent}
1207
1208 if ( isvalue(v1_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
1209 if ( isvalue(vt_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
1210 if ( isvalue(v_AllRec) ) { setverdict(fail); } else { setverdict(pass); };
1211 if ( isvalue(v_AllRec.r1) ) { setverdict(fail); } else { setverdict(pass); };
1212 if ( isvalue(v_AllRec.r2) ) { setverdict(fail); } else { setverdict(pass); };
1213
1214 v1_MyRec := c1_MyRec;
1215 v_AllRec := { r1 := c1_MyRec, r2 := c2_MyRec };
1216
1217 if ( isvalue(v1_MyRec) ) {setverdict(pass); } else { setverdict(fail); };
1218 if ( isvalue(v_AllRec.r1) ) { setverdict(pass); } else { setverdict(fail); };
1219 if ( isvalue(c1_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
1220 if ( isvalue(c_AllRec.r1) ) { setverdict(pass); } else { setverdict(fail); };
1221 if ( isvalue(p1_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
1222 if ( isvalue(p_AllRec.r1) ) { setverdict(pass); } else { setverdict(fail); };
1223
1224 if ( isvalue(v1_MyRec .f1) ) { setverdict(pass); } else { setverdict(fail); };
1225 if ( isvalue(v_AllRec.r1.f1) ) { setverdict(pass); } else { setverdict(fail); };
1226 if ( isvalue(c1_MyRec .f1) ) { setverdict(pass); } else { setverdict(fail); };
1227 if ( isvalue(c_AllRec.r1.f1) ) { setverdict(pass); } else { setverdict(fail); };
1228 if ( isvalue(p1_MyRec .f1) ) { setverdict(pass); } else { setverdict(fail); };
1229 if ( isvalue(p_AllRec.r1.f1) ) { setverdict(pass); } else { setverdict(fail); };
1230
1231 if ( isvalue(v1_MyRec .f2) ) { setverdict(fail); } else { setverdict(pass); };
1232 if ( isvalue(v_AllRec.r1.f2) ) { setverdict(fail); } else { setverdict(pass); };
1233 if ( isvalue(c1_MyRec .f2) ) { setverdict(fail); } else { setverdict(pass); };
1234 if ( isvalue(c_AllRec.r1.f2) ) { setverdict(fail); } else { setverdict(pass); };
1235 if ( isvalue(p1_MyRec .f2) ) { setverdict(fail); } else { setverdict(pass); };
1236 if ( isvalue(p_AllRec.r1.f2) ) { setverdict(fail); } else { setverdict(pass); };
1237
1238 v2_MyRec := c2_MyRec; //{ f1 := omit, f2 := "omit" };
1239
1240 if ( isvalue(v2_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
1241 if ( isvalue(v_AllRec.r2) ) { setverdict(pass); } else { setverdict(fail); };
1242 if ( isvalue(c2_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
1243 if ( isvalue(c_AllRec.r2) ) { setverdict(pass); } else { setverdict(fail); };
1244 if ( isvalue(p2_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
1245 if ( isvalue(p_AllRec.r2) ) { setverdict(pass); } else { setverdict(fail); };
1246
1247 if ( isvalue(v2_MyRec .f1) ) { setverdict(fail); } else { setverdict(pass); };
1248 if ( isvalue(v_AllRec.r2.f1) ) { setverdict(fail); } else { setverdict(pass); };
1249 if ( isvalue(p2_MyRec .f1) ) { setverdict(fail); } else { setverdict(pass); };
1250 if ( isvalue(p_AllRec.r2.f1) ) { setverdict(fail); } else { setverdict(pass); };
1251 if ( isvalue(c2_MyRec .f1) ) { setverdict(fail); } else { setverdict(pass); };
1252 if ( isvalue(c_AllRec.r2.f1) ) { setverdict(fail); } else { setverdict(pass); };
1253 if ( isvalue(v2_MyRec .f2) ) { setverdict(pass); } else { setverdict(fail); };
1254 if ( isvalue(v_AllRec.r2.f2) ) { setverdict(pass); } else { setverdict(fail); };
1255 if ( isvalue(p2_MyRec .f2) ) { setverdict(pass); } else { setverdict(fail); };
1256 if ( isvalue(p_AllRec.r2.f2) ) { setverdict(pass); } else { setverdict(fail); };
1257 if ( isvalue(c2_MyRec .f2) ) { setverdict(pass); } else { setverdict(fail); };
1258 if ( isvalue(c_AllRec.r2.f2) ) { setverdict(pass); } else { setverdict(fail); };
1259
1260 v1_MyRec := { f1 := omit, f2 := omit };
1261
1262 if ( isvalue(v1_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
1263 if ( isvalue(v1_MyRec.f1) ) { setverdict(fail); } else { setverdict(pass); };
1264 if ( isvalue(v1_MyRec.f2) ) { setverdict(fail); } else { setverdict(pass); };
1265 // can't modify c1_MyRec or p1_MyRec
1266
1267/************** templates ***************/
1268
1269 vt_MyRec := { f1 := 5, f2 := omit };
1270
1271 if ( isvalue(vt_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
1272 if ( isvalue(vt_MyRec.f1) ) { setverdict(pass); } else { setverdict(fail); };
1273 if ( isvalue(vt_MyRec.f2) ) { setverdict(fail); } else { setverdict(pass); };
1274
1275 vt_MyRec := { f1 := omit, f2 := "five" };
1276
1277 if ( isvalue(vt_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
1278 if ( isvalue(vt_MyRec.f1) ) { setverdict(fail); } else { setverdict(pass); };
1279 if ( isvalue(vt_MyRec.f2) ) { setverdict(pass); } else { setverdict(fail); };
1280
1281 vt_MyRec := { f1 := ?, f2 := "5" };
1282
1283 if ( isvalue(vt_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
1284 if ( isvalue(vt_MyRec.f1) ) { setverdict(fail); } else { setverdict(pass); };
1285 if ( isvalue(vt_MyRec.f2) ) { setverdict(pass); } else { setverdict(fail); };
1286
1287 vt_MyRec := { f1 := 5, f2 := * };
1288
1289 if ( isvalue(vt_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
1290 if ( isvalue(vt_MyRec.f1) ) { setverdict(pass); } else { setverdict(fail); };
1291 if ( isvalue(vt_MyRec.f2) ) { setverdict(fail); } else { setverdict(pass); };
1292
1293 vt_MyRec := { f1 := ?, f2 := * };
1294
1295 if ( isvalue(vt_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
1296 if ( isvalue(vt_MyRec.f1) ) { setverdict(fail); } else { setverdict(pass); };
1297 if ( isvalue(vt_MyRec.f2) ) { setverdict(fail); } else { setverdict(pass); };
1298
1299 if ( isvalue(pt_MyRec) ) { setverdict(pass); } else { setverdict(fail); }; // the fields are omit, but the record is bound
1300 if ( isvalue(pt_MyRec.f1) ) { setverdict(fail); } else { setverdict(pass); };
1301 if ( isvalue(pt_MyRec.f2) ) { setverdict(fail); } else { setverdict(pass); };
1302
1303 //so here it is expanded instead
1304 if ( isvalue(modifies vt_MyRec := { f1:=1, f2:="2" }) ) { setverdict(pass); } else {setverdict(fail, modifies vt_MyRec := { f1:=1, f2:="2" }, " should be bound"); };
1305
1306 if ( isvalue(t_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
1307
1308 //testing ifpresent
1309 if ( isvalue(ti) ) { setverdict(fail); } else { setverdict(pass); };
1310 if ( isvalue(rrr1) ) { setverdict(pass); } else { setverdict(fail); };
1311 if ( isvalue(rrr2) ) { setverdict(fail); } else { setverdict(pass); };
1312 if ( isvalue(rrr3) ) { setverdict(fail); } else { setverdict(pass); };
1313}
1314
1315testcase recordIsvalue2() runs on recordOper_mycomp
1316{
1317 var recordOper_myrec8 x1_MyRec := { f1 := 5, f2 := omit };
1318 var recordOper_myrec8 x2_MyRec := { f1 := omit, f2 := "omit" };
1319 var template recordOper_myrec8 xt_MyRec := { f1 := omit, f2 := omit };
1320 var AllRec x_AllRec := { r1 := x1_MyRec, r2 := x2_MyRec }
1321 f_isvalue_record(x1_MyRec, x2_MyRec, x_AllRec, xt_MyRec) ;
1322}
1323
1324 type record of integer IntegerList
1325 type record Ctx{
1326 IntegerList appData
1327 }
1328
1329testcase CR_TR00016681() runs on recordOper_mycomp
1330{
1331 var Ctx vu;
1332 // appData field: Unbound record of
1333 // isvalue:false, isbound:false
1334 if (isvalue(vu.appData)) { setverdict(fail); } else { setverdict(pass); }
1335 if (isbound(vu.appData)) { setverdict(fail); } else { setverdict(pass); }
1336 //lengthof(v1.appData) -> Dynamic Testcase Error
1337
1338 // The enclosing record: isbound === isvalue
1339 if (isvalue(vu)) { setverdict (fail); } else { setverdict(pass); }
1340 if (isbound(vu)) { setverdict (fail); } else { setverdict(pass); }
1341
1342 var Ctx v0 := {{}}
1343 // appData field: 0-length record of
1344 // isvalue: true, isbound:true
1345 if (not isvalue(v0.appData)) { setverdict (fail); }
1346 if (isbound(v0.appData)) { setverdict (pass); }
1347 else { setverdict(fail); }
1348
1349 // The enclosing record: isbound === isvalue
1350 if (isvalue(v0)) { setverdict (pass); } else { setverdict(fail); }
1351 if (isbound(v0)) { setverdict (pass); } else { setverdict(fail); }
1352
1353 if (lengthof(v0.appData) == 0) { setverdict(pass); }
1354 else { setverdict(fail); }
1355
1356 // appData field: 3-length with gaps
1357 // isvalue: false, isbound:true
1358 var Ctx v3 := { appData := { 1, -, 2 } }
1359 if (isvalue(v3.appData)) { setverdict (fail); }
1360 if (isbound(v3.appData)) { setverdict (pass); }
1361 else { setverdict(fail); }
1362
1363 if (lengthof(v3.appData) == 3) { setverdict(pass); }
1364 else { setverdict(fail); }
1365
1366 var integer i;
1367 if (isbound(i)) { setverdict (fail); } else { setverdict(pass); }
1368 if (isvalue(i)) { setverdict (fail); } else { setverdict(pass); }
1369 i := 42;
1370 if (isvalue(i)) { setverdict (pass); } else { setverdict(fail); }
1371 if (isbound(i)) { setverdict (pass); } else { setverdict(fail); }
1372}
1373
1374const MyRec2 c_myrec2_part:={
1375 roc:={},
1376 roi:={10,9,8},
1377 u:={ r:={ /*i:=1,*/ x:=1.0, c:="one"}},
1378 r:={ i:=1, x:=1.0, c:="one"}
1379}
1380
1381const MyRec2 c_myrec2_1:={
1382 roc:=omit,
1383 roi:={},
1384 u:={r:={ i:=1, x:=1.0, c:="one"}},
1385 r:={ i:=1, x:=1.0, c:="one"}
1386}
1387
1388type record MyRec2{
1389 ROC roc optional,
1390 ROI roi optional,
1391 MyUnion1 u optional,
1392 MyRecord1 r optional
1393}
1394
1395type record of charstring ROC;
1396type record of integer ROI;
1397type record MyRecord1 {
1398 integer i optional,
1399 float x optional,
1400 charstring c
1401}
1402
1403type union MyUnion1 {
1404 ROC roc,
1405 integer i,
1406 ROI roi,
1407 MyRecord1 r
1408}
1409
1410testcase tc_record_completlyInit() runs on recordOper_mycomp {
1411 var MyRec2 vl_r1:=c_myrec2_1;
1412 if(isbound(vl_r1)){setverdict(pass)}else {setverdict(fail)};
1413 var MyRec2 vl_r2:=c_myrec2_part;
1414 if(isbound(vl_r2)){setverdict(pass)}else {setverdict(fail)};
1415 var MyRec2 vl_r3:=c_myrec2_part;
1416 if(isbound(vl_r3)){setverdict(pass)}else {setverdict(fail)};
1417 var MyRec2 vl_r4:=c_myrec2_part;
1418 if(isbound(vl_r4.roc)){setverdict(pass)}else {setverdict(fail)};
1419 var MyRec2 vl_r5:=c_myrec2_part;
1420 if(isbound(vl_r5.roi)){setverdict(pass)}else {setverdict(fail)};
1421 var MyRec2 vl_r6:=c_myrec2_part;
1422 if(isbound(vl_r6.u)){setverdict(pass)}else {setverdict(fail)};
1423 var MyRec2 vl_r7:=c_myrec2_part;
1424 if(isbound(vl_r7.u.r)){setverdict(pass)}else {setverdict(fail)};
1425 var MyRec2 vl_r8:=c_myrec2_part;
1426 if(isbound(vl_r8.u.r.i)){setverdict(fail)}else {setverdict(pass)};
1427 var MyRec2 vl_r9:=c_myrec2_part;
1428 if(isbound(vl_r9.u.r.x)){setverdict(pass)}else {setverdict(fail)};
1429 var MyRec2 vl_r10:=c_myrec2_part;
1430 if(isbound(vl_r10.u.r.c)){setverdict(pass)}else {setverdict(fail)};
1431 var MyRec2 vl_r11:=c_myrec2_part;
1432 if(isbound(vl_r11.u.i)){setverdict(fail)}else {setverdict(pass)};
1433}
1434
1435testcase tc_record_partiallyInit12() runs on recordOper_mycomp {
1436 var MyRec2 vl_r:={ r:={i:=5}}
1437 if(isbound(vl_r.r)){setverdict(pass)}else {setverdict(fail)};
1438 if(isbound(vl_r.r.i)){setverdict(pass)}else {setverdict(fail)};
1439}
1440
1441testcase tc_record_partiallyInit13() runs on recordOper_mycomp {
1442 var MyRec2 vl_r:={ r:={i:=5,x:=-,c:= -}}
1443 if(isbound(vl_r)){setverdict(pass)}else {setverdict(fail)};
1444 if(isbound(vl_r.r)){setverdict(pass)}else {setverdict(fail)};
1445 if(isbound(vl_r.r.i)){setverdict(pass)}else {setverdict(fail)};
1446}
1447
1448 testcase tc_record_unbound() runs on recordOper_mycomp {
1449 var template MyRec2 vtl_rec2;
1450 if(ispresent(vtl_rec2)) {setverdict(fail)}else {setverdict(pass)};
1451 }
1452
1453 testcase tc_record_completlyInit_ispresent() runs on recordOper_mycomp {
1454 var MyRec2 vl_r1:=c_myrec2_1;
1455 if(ispresent(vl_r1)){setverdict(pass)}else {setverdict(fail)};
1456 var MyRec2 vl_r2:=c_myrec2_part;
1457 if(ispresent(vl_r2)){setverdict(pass)}else {setverdict(fail)};
1458 var MyRec2 vl_r3:=c_myrec2_part;
1459 if(ispresent(vl_r3.roc)){setverdict(pass)}else {setverdict(fail)};
1460 var MyRec2 vl_r4:=c_myrec2_part;
1461 if(ispresent(vl_r4.roi)){setverdict(pass)}else {setverdict(fail)};
1462 var MyRec2 vl_r5:=c_myrec2_part;
1463 if(ispresent(vl_r5.u)){setverdict(pass)}else {setverdict(fail)};
1464 var MyRec2 vl_r6:=c_myrec2_part;
1465 if(ispresent(vl_r6.u.r)){setverdict(pass)}else {setverdict(fail)};
1466 var MyRec2 vl_r7:=c_myrec2_part;
1467 if(ispresent(vl_r7.u.r.i)){setverdict(fail)}else {setverdict(pass)};
1468 var MyRec2 vl_r8:=c_myrec2_part;
1469 if(ispresent(vl_r8.u.r.x)){setverdict(pass)}else {setverdict(fail)};
1470 var MyRec2 vl_r9:=c_myrec2_part;
1471 if(ispresent(vl_r9.u.r.c)){setverdict(pass)}else {setverdict(fail)};
1472 var MyRec2 vl_r10:=c_myrec2_part;
1473 if(ispresent(vl_r10.u.i)){setverdict(fail)}else {setverdict(pass)};
1474 }
1475
1476 testcase tc_record_partiallyInit12_ispresent() runs on recordOper_mycomp {
1477 var MyRec2 vl_r:={ r:={i:=5}}
1478 if(ispresent(vl_r.r)){setverdict(pass)}else {setverdict(fail)};
1479 if(ispresent(vl_r.r.i)){setverdict(pass)}else {setverdict(fail)};
1480 }
1481
1482 testcase tc_record_partiallyInit13_ispresent() runs on recordOper_mycomp {
1483 var MyRec2 vl_r:={ r:={i:=5,x:=-,c:= -}}
1484 if(ispresent(vl_r)){setverdict(pass)}else {setverdict(fail)};
1485 if(ispresent(vl_r.r)){setverdict(pass)}else {setverdict(fail)};
1486 if(ispresent(vl_r.r.i)){setverdict(pass)}else {setverdict(fail)};
1487 }
1488
1489 testcase tc_record_omit() runs on recordOper_mycomp {
1490 var MyRec2 vl_r:={omit, omit, omit, omit}
1491 if(ispresent(vl_r)){setverdict(pass)}else {setverdict(fail)};
1492 if(ispresent(vl_r.roc)){setverdict(fail)}else {setverdict(pass)};
1493 if(ispresent(vl_r.roi)){setverdict(fail)}else {setverdict(pass)};
1494 if(ispresent(vl_r.u)){setverdict(fail)}else {setverdict(pass)};
1495 if(ispresent(vl_r.u.r)){setverdict(fail)}else {setverdict(pass)};
1496 if(ispresent(vl_r.u.r.i)){setverdict(fail)}else {setverdict(pass)};
1497 if(ispresent(vl_r.u.r.x)){setverdict(fail)}else {setverdict(pass)};
1498 if(ispresent(vl_r.u.r.c)){setverdict(fail)}else {setverdict(pass)};
1499 if(ispresent(vl_r.r)){setverdict(fail)}else {setverdict(pass)};
1500 if(ispresent(vl_r.r.i)){setverdict(fail)}else {setverdict(pass)};
1501 if(ispresent(vl_r.r.x)){setverdict(fail)}else {setverdict(pass)};
1502 if(ispresent(vl_r.r.c)){setverdict(fail)}else {setverdict(pass)};
1503 }
1504
1505 testcase tc_record_omit2() runs on recordOper_mycomp {
1506 var MyRec2 vl_r:={roc:=omit, roi:=omit,u:= omit,r:= omit}
1507 if(ispresent(vl_r)){setverdict(pass)}else {setverdict(fail)};
1508 if(ispresent(vl_r.roc)){setverdict(fail)}else {setverdict(pass)};
1509 if(ispresent(vl_r.roi)){setverdict(fail)}else {setverdict(pass)};
1510 if(ispresent(vl_r.u)){setverdict(fail)}else {setverdict(pass)};
1511 if(ispresent(vl_r.u.r)){setverdict(fail)}else {setverdict(pass)};
1512 if(ispresent(vl_r.u.r.i)){setverdict(fail)}else {setverdict(pass)};
1513 if(ispresent(vl_r.u.r.x)){setverdict(fail)}else {setverdict(pass)};
1514 if(ispresent(vl_r.u.r.c)){setverdict(fail)}else {setverdict(pass)};
1515 if(ispresent(vl_r.r)){setverdict(fail)}else {setverdict(pass)};
1516 if(ispresent(vl_r.r.i)){setverdict(fail)}else {setverdict(pass)};
1517 if(ispresent(vl_r.r.x)){setverdict(fail)}else {setverdict(pass)};
1518 if(ispresent(vl_r.r.c)){setverdict(fail)}else {setverdict(pass)};
1519 }
1520
1521 testcase tc_record_omit_HQ51693() runs on recordOper_mycomp {
1522 var recordOper_myrec9 r1 := {omit, omit};
1523 r1.f1 := r1.f2;
1524 if(ispresent(r1.f1) or ispresent(r1.f2)){setverdict(fail)}else {setverdict(pass)};
1525 }
1526
1527 testcase tc_recordOf_omit() runs on recordOper_mycomp {
1528 var MyRec2 vl_r:=c_myrec2_1;
1529 if(ispresent(vl_r.roc)){setverdict(fail)}else {setverdict(pass)};
1530 if(ispresent(vl_r.roc[0])){setverdict(fail)}else {setverdict(pass)};
1531 if(ispresent(vl_r.roi)){setverdict(pass)}else {setverdict(fail)};
1532 if(ispresent(vl_r.roi[0])){setverdict(fail)}else {setverdict(pass)};
1533 if(ispresent(vl_r.roi[90])){setverdict(fail)}else {setverdict(pass)};
1534 }
970ed795
EL		 1535
1536control {
1537 const recordOper_trecord cl_temp1:={ x1:=omit, x2:=3.4 }; // can constants be declared in the control part
1538 const recordOper_trecof cl_temp2:={ 'AF12'O };
1539 const recordOper_tset cl_temp3:={ x1:=234, x2:=1.9};
1540 const recordOper_tsetof cl_temp4:={"f","8"};
1541 const recordOper_tunion cl_temp5:={ x2:=1.3 };
1542 const typedefrecordComp_myrec cl_const14 := { // complex record
1543 x1 := { x1:=omit, x2:=3.4 },
1544 x2 := { 'AF12'O },
1545 x3 := { x1:=234, x2:=1.9},
1546 x4 := {"f","8"},
1547 x5 := { x2:=1.3 },
1548 x6 := {1,2,3}
1549 }
1550 var recordOper_trecord vl_temp1; // can variables be declared in the control part
1551 var recordOper_trecof vl_temp2;
1552 var recordOper_tset vl_temp3;
1553 var recordOper_tsetof vl_temp4;
1554 var recordOper_tunion vl_temp5;
1555 var typedefrecordComp_myrec vl_const14;
1556
1557 execute(recordAssign());
1558 execute(recordAssignIncomplete());
1559 execute(recordAssignOpt());
1560 execute(recordAssignRec());
1561 execute(recordAssignRecof());
1562 execute(recordAssignSet());
1563 execute(recordAssignSetof());
1564 execute(recordAssignUnion());
1565 execute(recordAssignElem());
1566 execute(recordAssignElemOpt());
1567 execute(recordAssignElemRec());
1568 execute(recordAssignElemRecof());
1569 execute(recordAssignElemSet());
1570 execute(recordAssignElemSetof());
1571 execute(recordAssignElemUnion());
1572 execute(recordSizeof());
1573 execute(recordConst());
1574 execute(recordConstOpt());
1575 execute(recordConstRec());
1576 execute(recordConstRecof());
1577 execute(recordConstSet());
1578 execute(recordConstSetof());
1579 execute(recordConstUnion());
1580 execute(recordComp());
1581 execute(recordCompOpt());
1582 execute(recordCompOptField());
1583 execute(recordCompRec());
1584 execute(recordCompRecof());
1585 execute(recordCompSet());
1586 execute(recordCompSetof());
1587 execute(recordCompUnion());
1588 execute(recordSubtypes());
1589 execute(recordIsvalue());
1590 execute(recordIsbound());
1591 execute(recordIsvalue2());
1592
1593 execute(CR_TR00016681());
1594
1595 execute(tc_record_completlyInit());
1596 execute(tc_record_partiallyInit12());
1597 execute(tc_record_partiallyInit13());
1598 execute(tc_record_unbound());
1599 execute(tc_record_completlyInit_ispresent());
1600 execute(tc_record_partiallyInit12_ispresent());
1601 execute(tc_record_partiallyInit13_ispresent());
1602 execute(tc_record_omit());
1603 execute(tc_record_omit2());
1604 execute(tc_record_omit_HQ51693());
1605 execute(tc_recordOf_omit());
970ed795
EL		 1606}
1607}
Titan Core - Deliverables
This page took 0.122722 seconds and 5 git commands to generate.