1 /******************************************************************************
2 * Copyright (c) 2000-2014 Ericsson Telecom AB
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 ******************************************************************************/
9 // ********** Type definitions *********************
10 type component setofOper_mycomp {};
11 type enumerated setofOper_myenum {xx1,xx2,xx3};
12 type record setofOper_trecord {
15 type record of octetstring setofOper_trecof;
16 type set setofOper_tset {
19 type set of charstring setofOper_tsetof;
20 type union setofOper_tunion {
23 type set of integer setofOper_mysetof1; // set of basic types
24 type set of setofOper_myenum setofOper_mysetof2; // set of enum
25 type set of setofOper_trecord setofOper_mysetof3; // set of record
26 type set of setofOper_trecof setofOper_mysetof4; // set of record of
27 type set of setofOper_tset setofOper_mysetof5; // set of set
28 type set of setofOper_tsetof setofOper_mysetof6; // set of set of
29 type set of setofOper_tunion setofOper_mysetof7; // set of union
30 // *************** Constanst ***********************
31 const setofOper_trecord setofOper_temp1:={ x1:=omit, x2:=3.4 };
32 const setofOper_trecof setofOper_temp2:={ 'AF12'O };
33 const setofOper_tset setofOper_temp3:={ x1:=234, x2:=1.9};
34 const setofOper_tsetof setofOper_temp4:={"f","8"};
35 const setofOper_tunion setofOper_temp5:={ x2:=1.3 };
36 const setofOper_mysetof1 setofOper_const1:={ 1,2 } //set of basic types
37 const setofOper_mysetof2 setofOper_const2:={ xx2, xx1 }
38 const setofOper_mysetof3 setofOper_const4:={ //set of record
39 { x1:=1, x2:=1.2 },setofOper_temp1 };
40 const setofOper_mysetof4 setofOper_const6:={ //set of record of
41 { '12AB'O, 'CD12'O }, setofOper_temp2 };
42 const setofOper_mysetof5 setofOper_const8:={ //set of set
43 { x1:=2, x2:=1.3}, setofOper_temp3 };
44 const setofOper_mysetof6 setofOper_const10:={ //set of set of
45 {"a","b"}, setofOper_temp4 }; //{"f","8"},
46 const setofOper_mysetof7 setofOper_const12:={ //set of union
47 { x1 :=3 }, setofOper_temp5 }; //{ x2:=1.3 }
49 testcase setofAssign() runs on setofOper_mycomp{
50 var setofOper_mysetof1 x1:={ 12,34} //set of basic types
51 var setofOper_mysetof1 x2,x3,x4;
56 if (x1[0]==12) {setverdict(pass);} //at declaration
57 else {setverdict(fail);}
58 if (x1[1]==34) {setverdict(pass);}
59 else {setverdict(fail);}
60 if (x2[0]==32) {setverdict(pass);} //later
61 else {setverdict(fail);}
62 if (x2[1]==12) {setverdict(pass);}
63 else {setverdict(fail);}
64 if (x3[0]==32) {setverdict(pass);} //later, change of size
65 else {setverdict(fail);}
66 if (x3[1]==12) {setverdict(pass);}
67 else {setverdict(fail);}
68 //if (x4=={}) {setverdict(pass);} // empty set of
69 // else {setverdict(fail);}
72 testcase setofAssignEnum() runs on setofOper_mycomp{
73 var setofOper_mysetof2 x1:={ xx2 } //set of enum
74 var setofOper_mysetof2 x2;
77 if (x1[0]==xx2) {setverdict(pass);}
78 else {setverdict(fail);}
80 if (x2[0]==xx2) {setverdict(pass);}
81 else {setverdict(fail);}
82 if (x2[1]==xx1) {setverdict(pass);}
83 else {setverdict(fail);}
86 testcase setofAssignRec() runs on setofOper_mycomp{
87 var setofOper_trecord temp1:={ x1:=omit, x2:=3.4 };
88 var setofOper_mysetof3 x1:={ //set of record
89 { x1:=1, x2:=1.2 }, temp1 };
90 var setofOper_mysetof3 x2;
91 x2:={ { x1:=1, x2:=1.2 }, temp1 };
92 if (x1[0].x1==1) {setverdict(pass);} //at declaration
93 else {setverdict(fail);}
94 if (x1[0].x2==1.2) {setverdict(pass);}
95 else {setverdict(fail);}
96 if (x1[1]==temp1) {setverdict(pass);}
97 else {setverdict(fail);}
98 if (x2[0].x1==1) {setverdict(pass);} //later
99 else {setverdict(fail);}
100 if (x2[0].x2==1.2) {setverdict(pass);}
101 else {setverdict(fail);}
102 if (not(ispresent(x2[1].x1))) {setverdict(pass);}
103 else {setverdict(fail);}
104 if (x2[1].x2==3.4) {setverdict(pass);}
105 else {setverdict(fail);}
108 testcase setofAssignRecof() runs on setofOper_mycomp{
109 var setofOper_trecof temp2:={'AF12'O};
110 var setofOper_mysetof4 x1:={ //set of record of
111 { '12AB'O, 'CD12'O }, temp2 };
112 var setofOper_mysetof4 x2;
113 x2:={ { '12AB'O, 'CD12'O }, temp2 };
114 if (x1[0][0]=='12AB'O) {setverdict(pass);} //at declaration
115 else {setverdict(fail);}
116 if (x1[0][1]=='CD12'O) {setverdict(pass);}
117 else {setverdict(fail);}
118 if (x1[1]==temp2) {setverdict(pass);}
119 else {setverdict(fail);}
120 if (x2[0][0]=='12AB'O) {setverdict(pass);} //later
121 else {setverdict(fail);}
122 if (x2[0][1]=='CD12'O) {setverdict(pass);}
123 else {setverdict(fail);}
124 if (x2[1][0]=='AF12'O) {setverdict(pass);}
125 else {setverdict(fail);}
128 testcase setofAssignSet() runs on setofOper_mycomp{
129 var setofOper_tset temp1:={ x1:=2, x2:=omit };
130 var setofOper_mysetof5 x1:={ //set of set
131 { x1:=1, x2:=1.2 }, temp1 };
132 var setofOper_mysetof5 x2;
133 x2:={ { x1:=1, x2:=1.2 }, temp1 };
134 if (x1[0].x1==1) {setverdict(pass);} //at declaration
135 else {setverdict(fail);}
136 if (x1[0].x2==1.2) {setverdict(pass);}
137 else {setverdict(fail);}
138 if (x1[1]==temp1) {setverdict(pass);}
139 else {setverdict(fail);}
140 if (x2[0].x1==1) {setverdict(pass);} //later
141 else {setverdict(fail);}
142 if (x2[0].x2==1.2) {setverdict(pass);}
143 else {setverdict(fail);}
144 if (x2[1].x1==2) {setverdict(pass);}
145 else {setverdict(fail);}
146 if (not(ispresent(x2[1].x2))) {setverdict(pass);}
147 else {setverdict(fail);}
150 testcase setofAssignSetof() runs on setofOper_mycomp{
151 var setofOper_tsetof temp2:={"a","7"};
152 var setofOper_mysetof6 x1:={ //set of set of
153 { "1", "a" }, temp2 };
154 var setofOper_mysetof6 x2;
155 x2:={ { "1", "a" }, temp2 };
156 if (x1[0][0]=="1") {setverdict(pass);} //at declaration
157 else {setverdict(fail);}
158 if (x1[0][1]=="a") {setverdict(pass);}
159 else {setverdict(fail);}
160 if (x1[1]==temp2) {setverdict(pass);}
161 else {setverdict(fail);}
162 if (x2[0][0]=="1") {setverdict(pass);} //later
163 else {setverdict(fail);}
164 if (x2[0][1]=="a") {setverdict(pass);}
165 else {setverdict(fail);}
166 if (x2[1][0]=="a") {setverdict(pass);}
167 else {setverdict(fail);}
168 if (x2[1][1]=="7") {setverdict(pass);}
169 else {setverdict(fail);}
172 testcase setofAssignUnion() runs on setofOper_mycomp{
173 var setofOper_tunion temp5 := {x2:=1.3}
174 var setofOper_mysetof7 x1:={ //set of union
175 { x1 :=3 }, temp5 }; //{ x2:=1.3
176 var setofOper_mysetof7 x2;
177 x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
178 if (x1[0].x1==3) {setverdict(pass);} //at declaration
179 else {setverdict(fail);}
180 if (ischosen(x1[0].x1)) {setverdict(pass);}
181 else {setverdict(fail);}
182 if (not(ischosen(x1[0].x2))) {setverdict(pass);}
183 else {setverdict(fail);}
184 if (x1[1]==temp5) {setverdict(pass);}
185 else {setverdict(fail);}
186 if (x2[0].x1==3) {setverdict(pass);} //later
187 else {setverdict(fail);}
188 if (ischosen(x2[0].x1)) {setverdict(pass);}
189 else {setverdict(fail);}
190 if (not(ischosen(x2[0].x2))) {setverdict(pass);}
191 else {setverdict(fail);}
192 if (x2[1].x2==1.3) {setverdict(pass);}
193 else {setverdict(fail);}
194 if (ischosen(x2[1].x2)) {setverdict(pass);}
195 else {setverdict(fail);}
196 if (not(ischosen(x2[1].x1))) {setverdict(pass);}
197 else {setverdict(fail);}
200 testcase setofAssignElem() runs on setofOper_mycomp{
201 var setofOper_mysetof1 x1,x2,x3,x4,x5; //set of basic types
207 x2[0]:=3; //change element to value
208 x3[0]:=x1[0]; //change element to element
209 x4[2]:=2; // add element
210 x5[2]:=3; // out of order
211 if (x1[1]==2) {setverdict(pass);} //accessing individual element
212 else {setverdict(fail);}
213 if (x2[0]==3) {setverdict(pass);} // change element to value
214 else {setverdict(fail);}
215 if (x2[1]==2) {setverdict(pass);}
216 else {setverdict(fail);}
217 if (x3[0]==3) {setverdict(pass);} // change element to element
218 else {setverdict(fail);}
219 if (x3[1]==2) {setverdict(pass);}
220 else {setverdict(fail);}
221 if (x4[0]==1) {setverdict(pass);} // add element
222 else {setverdict(fail);}
223 if (x4[1]==2) {setverdict(pass);}
224 else {setverdict(fail);}
225 if (x4[2]==2) {setverdict(pass);}
226 else {setverdict(fail);}
227 if (x5[2]==3) {setverdict(pass);} // out of order
228 else {setverdict(fail);}
231 testcase setofAssignElemEnum() runs on setofOper_mycomp{
232 var setofOper_mysetof2 x1:={ xx1, xx2 }; //set of enumerated
233 var setofOper_mysetof2 x2, x3;
235 x1[0]:=xx3; //change element
236 x2[2]:=xx3; // add element
237 x3[2]:=xx3; // out of order
238 if (x1[0]==xx3) {setverdict(pass);} // change element
239 else {setverdict(fail);}
240 if (x1[1]==xx2) {setverdict(pass);}
241 else {setverdict(fail);}
242 if (x2[0]==xx1) {setverdict(pass);} // add element
243 else {setverdict(fail);}
244 if (x2[1]==xx2) {setverdict(pass);}
245 else {setverdict(fail);}
246 if (x2[2]==xx3) {setverdict(pass);}
247 else {setverdict(fail);}
248 if (x3[2]==xx3) {setverdict(pass);} // out of order
249 else {setverdict(fail);}
252 testcase setofAssignElemRec() runs on setofOper_mycomp{
253 var setofOper_mysetof3 x1,x2,x3; //set of record
254 x1:={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
259 x2[2]:= {x1:=2, x2:=1.3}; // add element
260 x3[1]:= {x1:=2, x2:=1.3}; //out of order
261 if (x1[0].x1==2) {setverdict(pass);} // change element
262 else {setverdict(fail);}
263 if (x1[0].x2==1.2) {setverdict(pass);}
264 else {setverdict(fail);}
265 if (x1[1].x1==3) {setverdict(pass);}
266 else {setverdict(fail);}
267 if (x1[1].x2==3.4) {setverdict(pass);}
268 else {setverdict(fail);}
269 if (x2[0].x1==1) {setverdict(pass);} //add element
270 else {setverdict(fail);}
271 if (x2[0].x2==1.2) {setverdict(pass);}
272 else {setverdict(fail);}
273 if (not(ispresent(x2[1].x1))) {setverdict(pass);}
274 else {setverdict(fail);}
275 if (x2[1].x2==3.4) {setverdict(pass);}
276 else {setverdict(fail);}
277 if (x2[2].x1==2) {setverdict(pass);}
278 else {setverdict(fail);}
279 if (x2[2].x2==1.3) {setverdict(pass);}
280 else {setverdict(fail);}
281 if (x3[1].x1==2) {setverdict(pass);} // out of order
282 else {setverdict(fail);}
283 if (x3[1].x2==1.3) {setverdict(pass);}
284 else {setverdict(fail);}
288 testcase setofAssignElemRecof() runs on setofOper_mycomp{
289 var setofOper_mysetof4 x1,x2,x3; //set of record of
290 x1:={ { '12AB'O, 'CD12'O }, { 'ABCD'O } };
292 x1[0][1]:='34AB'O; //change element
293 x2[2]:={ '1234'O}; //add element
294 x3[2]:={'12CD'O}; //out of order
295 if (x1[0][0]=='12AB'O) {setverdict(pass);} // change element
296 else {setverdict(fail);}
297 if (x1[0][1]=='34AB'O) {setverdict(pass);}
298 else {setverdict(fail);}
299 if (x1[1][0]=='ABCD'O) {setverdict(pass);}
300 else {setverdict(fail);}
301 if (x2[0][0]=='12AB'O) {setverdict(pass);} // add element
302 else {setverdict(fail);}
303 if (x2[0][1]=='CD12'O) {setverdict(pass);}
304 else {setverdict(fail);}
305 if (x2[1][0]=='ABCD'O) {setverdict(pass);}
306 else {setverdict(fail);}
307 if (x2[2][0]=='1234'O) {setverdict(pass);}
308 else {setverdict(fail);}
309 if (x3[2][0]=='12CD'O) {setverdict(pass);} //out of order
310 else {setverdict(fail);}
313 testcase setofAssignElemSet() runs on setofOper_mycomp{
314 var setofOper_mysetof5 x1,x2,x3 //set of set
315 x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
316 x2:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
317 x1[0].x2:=3.4; //change element
318 x2[2]:={ x1:=2, x2:=1.3 }; // add element
319 x3[2]:={ x1:=2, x2:=1.3 }; // out of order
320 if (x1[0].x1==1) {setverdict(pass);} //change element
321 else {setverdict(fail);}
322 if (x1[0].x2==3.4) {setverdict(pass);}
323 else {setverdict(fail);}
324 if (x1[1].x1==2) {setverdict(pass);}
325 else {setverdict(fail);}
326 if (not(ispresent(x1[1].x2))) {setverdict(pass);}
327 else {setverdict(fail);}
328 if (x2[0].x1==1) {setverdict(pass);} //add element
329 else {setverdict(fail);}
330 if (x2[0].x2==1.2) {setverdict(pass);}
331 else {setverdict(fail);}
332 if (x2[1].x1==2) {setverdict(pass);}
333 else {setverdict(fail);}
334 if (not(ispresent(x2[1].x2))) {setverdict(pass);}
335 else {setverdict(fail);}
336 if (x2[2].x1==2) {setverdict(pass);}
337 else {setverdict(fail);}
338 if (x2[2].x2==1.3) {setverdict(pass);}
339 else {setverdict(fail);}
340 if (x3[2].x1==2) {setverdict(pass);} //out of order
341 else {setverdict(fail);}
342 if (x3[2].x2==1.3) {setverdict(pass);}
343 else {setverdict(fail);}
346 testcase setofAssignElemSetof() runs on setofOper_mycomp{
347 var setofOper_tsetof temp2:={"a","7"};
348 var setofOper_mysetof6 x1,x2,x3; //set of set of
349 x1:={ { "1" }, {"a","7"}};
350 x2:={ { "1" }, {"a","7"}};
351 x1[0][0]:="h"; // change element
352 x2[2]:={"2"}; //add element
353 x3[2]:={"2"}; //out of order
354 if (x1[0][0]=="h") {setverdict(pass);} //change element
355 else {setverdict(fail);}
356 if (x1[1][0]=="a") {setverdict(pass);}
357 else {setverdict(fail);}
358 if (x1[1][1]=="7") {setverdict(pass);}
359 else {setverdict(fail);}
360 if (x2[0][0]=="1") {setverdict(pass);} //add element
361 else {setverdict(fail);}
362 if (x2[1][0]=="a") {setverdict(pass);}
363 else {setverdict(fail);}
364 if (x2[1][1]=="7") {setverdict(pass);}
365 else {setverdict(fail);}
366 if (x2[2][0]=="2") {setverdict(pass);}
367 else {setverdict(fail);}
368 if (x3[2][0]=="2") {setverdict(pass);} // out of order
369 else {setverdict(fail);}
372 testcase setofAssignElemUnion() runs on setofOper_mycomp{
373 var setofOper_tunion temp5 := {x2:=1.3}
374 var setofOper_mysetof7 x1,x2,x3; //set of union
375 x1:={ {x1 :=3 }, {x2:=1.3} };
376 x2:={ {x1 :=3 }, {x2:=1.3} };
377 x1[0].x2:=3.4; //change element
378 x2[2]:={ x2:=1.4}; // add element
379 x3[2]:={ x2:=1.4}; // out of order
380 if (x1[0].x2==3.4) {setverdict(pass);} //change element
381 else {setverdict(fail);}
382 if (ischosen(x1[0].x2)) {setverdict(pass);}
383 else {setverdict(fail);}
384 if (not(ischosen(x1[0].x1))) {setverdict(pass);}
385 else {setverdict(fail);}
386 if (x1[1].x2==1.3) {setverdict(pass);}
387 else {setverdict(fail);}
388 if (ischosen(x1[1].x2)) {setverdict(pass);}
389 else {setverdict(fail);}
390 if (not(ischosen(x1[1].x1))) {setverdict(pass);}
391 else {setverdict(fail);}
392 if (x2[0].x1==3) {setverdict(pass);} //add element
393 else {setverdict(fail);}
394 if (ischosen(x2[0].x1)) {setverdict(pass);}
395 else {setverdict(fail);}
396 if (not(ischosen(x2[0].x2))) {setverdict(pass);}
397 else {setverdict(fail);}
398 if (x2[1].x2==1.3) {setverdict(pass);}
399 else {setverdict(fail);}
400 if (ischosen(x2[1].x2)) {setverdict(pass);}
401 else {setverdict(fail);}
402 if (not(ischosen(x2[1].x1))) {setverdict(pass);}
403 else {setverdict(fail);}
404 if (x2[2].x2==1.4) {setverdict(pass);}
405 else {setverdict(fail);}
406 if (ischosen(x2[2].x2)) {setverdict(pass);}
407 else {setverdict(fail);}
408 if (not(ischosen(x2[2].x1))) {setverdict(pass);}
409 else {setverdict(fail);}
410 if (x3[2].x2==1.4) {setverdict(pass);} //out of order
411 else {setverdict(fail);}
412 if (ischosen(x3[2].x2)) {setverdict(pass);}
413 else {setverdict(fail);}
414 if (not(ischosen(x3[2].x1))) {setverdict(pass);}
415 else {setverdict(fail);}
418 testcase setofConst() runs on setofOper_mycomp{
419 const setofOper_mysetof1 const1:={1,2,3} //set of basic types
420 if (setofOper_const1[0]==1) {setverdict(pass);} //definition part
421 else {setverdict(fail);}
422 if (setofOper_const1[1]==2) {setverdict(pass);}
423 else {setverdict(fail);}
424 if (const1[0]==1) {setverdict(pass);} //testcase
425 else {setverdict(fail);}
426 if (const1[1]==2) {setverdict(pass);}
427 else {setverdict(fail);}
428 if (const1[2]==3) {setverdict(pass);}
429 else {setverdict(fail);}
432 testcase setofConstEnum() runs on setofOper_mycomp{
433 const setofOper_mysetof2 const1:={xx1,xx2,xx3} //set of enumerated
434 if (setofOper_const2[0]==xx2) {setverdict(pass);} //definition part
435 else {setverdict(fail);}
436 if (setofOper_const2[1]==xx1) {setverdict(pass);}
437 else {setverdict(fail);}
438 if (const1[0]==xx1) {setverdict(pass);} //testcase
439 else {setverdict(fail);}
440 if (const1[1]==xx2) {setverdict(pass);}
441 else {setverdict(fail);}
442 if (const1[2]==xx3) {setverdict(pass);}
443 else {setverdict(fail);}
446 testcase setofConstRec() runs on setofOper_mycomp{
447 const setofOper_mysetof3 const4:={ //set of record
448 { x1:=1, x2:=1.2 }, setofOper_temp1 };
449 if (setofOper_const4[0].x1==1) {setverdict(pass);} //definition part
450 else {setverdict(fail);}
451 if (setofOper_const4[0].x2==1.2) {setverdict(pass);}
452 else {setverdict(fail);}
453 if (setofOper_const4[1]==setofOper_temp1) {setverdict(pass);}
454 else {setverdict(fail);}
455 if (const4[0].x1==1) {setverdict(pass);} //testcase
456 else {setverdict(fail);}
457 if (const4[0].x2==1.2) {setverdict(pass);}
458 else {setverdict(fail);}
459 if (const4[1]==setofOper_temp1) {setverdict(pass);}
460 else {setverdict(fail);}
463 testcase setofConstRecof() runs on setofOper_mycomp{
464 const setofOper_mysetof4 const6:={ //set of record of
465 { '12AB'O, 'CD12'O }, setofOper_temp2 };
466 if (setofOper_const6[0][0]=='12AB'O) {setverdict(pass);} //definition part
467 else {setverdict(fail);}
468 if (setofOper_const6[0][1]=='CD12'O) {setverdict(pass);}
469 else {setverdict(fail);}
470 if (setofOper_const6[1]==setofOper_temp2) {setverdict(pass);}
471 else {setverdict(fail);}
472 if (const6[0][0]=='12AB'O) {setverdict(pass);} //testcase
473 else {setverdict(fail);}
474 if (const6[0][1]=='CD12'O) {setverdict(pass);}
475 else {setverdict(fail);}
476 if (const6[1]==setofOper_temp2) {setverdict(pass);}
477 else {setverdict(fail);}
480 testcase setofConstSet() runs on setofOper_mycomp{
481 const setofOper_mysetof5 const8:={ //set of set
482 { x1:=2, x2:=1.3}, setofOper_temp3 };
483 if (setofOper_const8[0].x1==2) {setverdict(pass);} //definition part
484 else {setverdict(fail);}
485 if (setofOper_const8[0].x2==1.3) {setverdict(pass);}
486 else {setverdict(fail);}
487 if (setofOper_const8[1]==setofOper_temp3) {setverdict(pass);}
488 else {setverdict(fail);}
489 if (const8[0].x1==2) {setverdict(pass);} //testcase
490 else {setverdict(fail);}
491 if (const8[0].x2==1.3) {setverdict(pass);}
492 else {setverdict(fail);}
493 if (const8[1]==setofOper_temp3) {setverdict(pass);}
494 else {setverdict(fail);}
497 testcase setofConstSetof() runs on setofOper_mycomp{
498 const setofOper_mysetof6 const10:={ //set of set of
499 {"a","b"}, {"f","8"} };
500 if (setofOper_const10[0][0]=="a") {setverdict(pass);} //definition part
501 else {setverdict(fail);}
502 if (setofOper_const10[0][1]=="b") {setverdict(pass);}
503 else {setverdict(fail);}
504 if (setofOper_const10[1]==setofOper_temp4) {setverdict(pass);}
505 else {setverdict(fail);}
506 if (const10[0][0]=="a") {setverdict(pass);} //testcase
507 else {setverdict(fail);}
508 if (const10[0][1]=="b") {setverdict(pass);}
509 else {setverdict(fail);}
510 if (const10[1][0]=="f") {setverdict(pass);}
511 else {setverdict(fail);}
512 if (const10[1][1]=="8") {setverdict(pass);}
513 else {setverdict(fail);}
516 testcase setofConstUnion() runs on setofOper_mycomp{
517 const setofOper_mysetof7 const12:={ //set of union
518 { x1 :=3 }, { x2:=1.3 } };
519 if (setofOper_const12[0].x1==3) {setverdict(pass);} //definition part
520 else {setverdict(fail);}
521 if (ischosen(setofOper_const12[0].x1)) {setverdict(pass);}
522 else {setverdict(fail);}
523 if (not(ischosen(setofOper_const12[0].x2))) {setverdict(pass);}
524 else {setverdict(fail);}
525 if (setofOper_const12[1]==setofOper_temp5) {setverdict(pass);}
526 else {setverdict(fail);}
527 if (const12[0].x1==3) {setverdict(pass);} //testcase
528 else {setverdict(fail);}
529 if (ischosen(const12[0].x1)) {setverdict(pass);}
530 else {setverdict(fail);}
531 if (not(ischosen(const12[0].x2))) {setverdict(pass);}
532 else {setverdict(fail);}
533 if (const12[1].x2==1.3) {setverdict(pass);}
534 else {setverdict(fail);}
535 if (ischosen(const12[1].x2)) {setverdict(pass);}
536 else {setverdict(fail);}
537 if (not(ischosen(const12[1].x1))) {setverdict(pass);}
538 else {setverdict(fail);}
541 testcase setofConstComp() runs on setofOper_mycomp{
542 const setofOper_mysetof1 x1:={ 1,2,3 };
543 const setofOper_mysetof1 x2:={ 1,2,3 };
544 const setofOper_mysetof1 x3:={ 1,2 };
545 const setofOper_mysetof1 x4:={ 3,1,2 };
546 if (x1==x2) {setverdict(pass);}
547 else {setverdict(fail);}
548 if (not(x1==x3)) {setverdict(pass);}
549 else {setverdict(fail);}
550 if (x4==x2) {setverdict(pass);} // out of order
551 else {setverdict(fail);}
552 if (x1!=x3) {setverdict(pass);}
553 else {setverdict(fail);}
554 if (not(x1!=x2)) {setverdict(pass);}
555 else {setverdict(fail);}
556 if (not(x4!=x2)) {setverdict(pass);} // out of order
557 else {setverdict(fail);}
560 testcase setofComp() runs on setofOper_mycomp{
561 var setofOper_mysetof1 x1,x2,x3,x4; //set of basic types
566 if (x1==x2) {setverdict(pass);}
567 else {setverdict(fail);}
568 if (not(x1==x3)) {setverdict(pass);}
569 else {setverdict(fail);}
570 if (x4==x2) {setverdict(pass);} // out of order
571 else {setverdict(fail);}
572 if (x1!=x3) {setverdict(pass);}
573 else {setverdict(fail);}
574 if (not(x1!=x2)) {setverdict(pass);}
575 else {setverdict(fail);}
576 if (not(x4!=x2)) {setverdict(pass);} // out of order
577 else {setverdict(fail);}
580 testcase setofCompEnum() runs on setofOper_mycomp{
581 var setofOper_mysetof2 x1,x2,x3,x4; //set of enumerated
586 if (x1==x2) {setverdict(pass);}
587 else {setverdict(fail);}
588 if (not(x1==x3)) {setverdict(pass);}
589 else {setverdict(fail);}
590 if (x4==x2) {setverdict(pass);} //out of order
591 else {setverdict(fail);}
592 if (x1!=x3) {setverdict(pass);}
593 else {setverdict(fail);}
594 if (not(x1!=x2)) {setverdict(pass);}
595 else {setverdict(fail);}
596 if (not(x4!=x2)) {setverdict(pass);} // out of order
597 else {setverdict(fail);}
600 testcase setofCompRec() runs on setofOper_mycomp{
601 var setofOper_mysetof3 x1,x2,x3,x4; // set of record
602 x1 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
603 x2 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
604 x3 :={ { x1:=2, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
605 x4 :={ { x1:=omit, x2:=3.4 }, { x1:=1, x2:=1.2 } };
606 if (x1==x2) {setverdict(pass);}
607 else {setverdict(fail);}
608 if (not(x1==x3)) {setverdict(pass);}
609 else {setverdict(fail);}
610 if (x4==x2) {setverdict(pass);} //out of order
611 else {setverdict(fail);}
612 if (x1!=x3) {setverdict(pass);}
613 else {setverdict(fail);}
614 if (not(x1!=x2)) {setverdict(pass);}
615 else {setverdict(fail);}
616 if (not(x4!=x2)) {setverdict(pass);} // out of order
617 else {setverdict(fail);}
621 testcase setofCompRecof() runs on setofOper_mycomp{
622 var setofOper_mysetof4 x1,x2,x3,x4; //set of record of
623 x1:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
624 x2:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
625 x3:={ { '12AB'O }, {'AF12'O} };
626 x4:={ {'AF12'O}, { '12AB'O, 'CD12'O } };
627 if (x1==x2) {setverdict(pass);}
628 else {setverdict(fail);}
629 if (not(x1==x3)) {setverdict(pass);}
630 else {setverdict(fail);}
631 if (x4==x2) {setverdict(pass);} //out of order
632 else {setverdict(fail);}
633 if (x2!=x3) {setverdict(pass);}
634 else {setverdict(fail);}
635 if (not(x1!=x2)) {setverdict(pass);}
636 else {setverdict(fail);}
637 if (not(x4!=x2)) {setverdict(pass);} //out of order
638 else {setverdict(fail);}
641 testcase setofCompSet() runs on setofOper_mycomp{
642 var setofOper_tset temp1:={ x1:=2, x2:=omit };
643 var setofOper_mysetof5 x1,x2,x3,x4; //set of set
644 x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit } };
645 x2:={ { x2:=1.2, x1:=1 }, { x1:=2, x2:=omit }};
646 x3:={ { x1:=1, x2:=1.2 } };
647 x4:={ { x1:=2, x2:=omit }, { x2:=1.2, x1:=1 } };
648 if (x1==x2) {setverdict(pass);}
649 else {setverdict(fail);}
650 if (not(x2==x3)) {setverdict(pass);}
651 else {setverdict(fail);}
652 if (x4==x2) {setverdict(pass);} //out of order
653 else {setverdict(fail);}
654 if (x1!=x3) {setverdict(pass);}
655 else {setverdict(fail);}
656 if (not(x1!=x2)) {setverdict(pass);}
657 else {setverdict(fail);}
658 if (not(x4!=x2)) {setverdict(pass);} //out of order
659 else {setverdict(fail);}
662 testcase setofCompSetof() runs on setofOper_mycomp{
663 var setofOper_tsetof temp2:={"a","7"};
664 var setofOper_mysetof6 x1,x2,x3,x4; //set of set of
665 x1:={ { "1", "a" }, temp2 };
666 x2:={ { "1", "a" }, {"a","7"} };
667 x3:={ { "1", "a" } };
668 x4:={ {"a","7"}, { "1", "a" } };
669 if (x1==x2) {setverdict(pass);}
670 else {setverdict(fail);}
671 if (not(x2==x3)) {setverdict(pass);}
672 else {setverdict(fail);}
673 if (x4==x2) {setverdict(pass);} //out of order
674 else {setverdict(fail);}
675 if (x1!=x3) {setverdict(pass);}
676 else {setverdict(fail);}
677 if (not(x1!=x2)) {setverdict(pass);}
678 else {setverdict(fail);}
679 if (not(x4!=x2)) {setverdict(pass);} // out of order
680 else {setverdict(fail);}
683 testcase setofCompUnion() runs on setofOper_mycomp{
684 var setofOper_tunion temp5 := {x2:=1.3}
685 var setofOper_mysetof7 x1,x2,x3,x4; //set of union
686 x1:={ { x1 :=3 }, { x2:=1.3 } };
687 x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
688 x3:={ { x2 :=3.9 },temp5 }; //{ x2:=1.3 }
689 x4:={ { x2:=1.3 }, { x1 :=3 } };
690 if (x1==x2) {setverdict(pass);}
691 else {setverdict(fail);}
692 if (not(x1==x3)) {setverdict(pass);}
693 else {setverdict(fail);}
694 if (x4==x2) {setverdict(pass);} //out of order
695 else {setverdict(fail);}
696 if (x2!=x3) {setverdict(pass);}
697 else {setverdict(fail);}
698 if (not(x1!=x2)) {setverdict(pass);}
699 else {setverdict(fail);}
700 if (not(x4!=x2)) {setverdict(pass);} //out of order
701 else {setverdict(fail);}
705 testcase setofCompUnbound() runs on setofOper_mycomp{
706 var setofOper_mysetof1 x1,x2,x3,x4;
711 if (x1 == x2) {setverdict(pass);}
712 else {setverdict(fail);}
713 if (x1 == x3) {setverdict(pass);}
714 else {setverdict(fail);}
715 if (x1 == x4) {setverdict(pass);}
716 else {setverdict(fail);}
719 testcase setofListOperator() runs on setofOper_mycomp{
720 var setofOper_mysetof1 x1:={1,2};
721 var setofOper_mysetof1 x2,x3,x4,x5,x6; //set of basic types
722 var setofOper_mysetof1 res1, res2, res3, res4;
731 res3 := x2 & x3 & x5;
733 if (res1 == {1,2,1,2}) {setverdict(pass);}
734 else {setverdict(fail);}
735 if (res2 == {1,2,1}) {setverdict(pass);}
736 else {setverdict(fail);}
737 if (res3 == {1,2,1}) {setverdict(pass);}
738 else {setverdict(fail);}
739 if (res4 == {1,1,3}) {setverdict(pass);}
740 else {setverdict(fail);}
743 testcase setofRotateOperators() runs on setofOper_mycomp{
744 var setofOper_mysetof1 x1:={1,2,3,4,5};
745 var setofOper_mysetof1 x2,x3,x4,x5,x6,x7; //set of basic types
752 if (x2 == x1) {setverdict(pass);}
753 else {setverdict(fail);}
754 if (x3 == x1) {setverdict(pass);}
755 else {setverdict(fail);}
756 if (x4 == x1) {setverdict(pass);}
757 else {setverdict(fail);}
758 if (x5 == x1) {setverdict(pass);}
759 else {setverdict(fail);}
760 if (x6 == x1) {setverdict(pass);}
761 else {setverdict(fail);}
762 if (x7 == x1) {setverdict(pass);}
763 else {setverdict(fail);}
766 testcase setofLengthof() runs on setofOper_mycomp{
767 // lengthof returns the sequential number of the last initialized element of the set of list type
768 var setofOper_mysetof1 x1:={1,2};
769 var setofOper_mysetof1 x2,x3,x4,x5,x6; //set of basic types
773 x3:={1,2}; //change size by assignment
774 x4[1]:=3; //change size by adding element
775 x5:={}; //empty set of
776 x6[2]:=1; //out of order
777 if (lengthof(x1)==2) {setverdict(pass);} //assignment at declaration
778 else {setverdict(fail);}
779 if (lengthof(x2)==2) {setverdict(pass);} //assignment later
780 else {setverdict(fail);}
781 if (lengthof(x3)==2) {setverdict(pass);} //change size by assignment
782 else {setverdict(fail);}
783 if (lengthof(x4)==2) {setverdict(pass);} //change size by adding element
784 else {setverdict(fail);}
785 if (lengthof(x5)==0) {setverdict(pass);} //empty set of
786 else {setverdict(fail);}
787 if (lengthof(x6)==3) {setverdict(pass);} //out of order
788 else {setverdict(fail);}
791 testcase setofSizeof() runs on setofOper_mycomp{
792 var setofOper_mysetof1 x1:={1,2};
793 var setofOper_mysetof1 x2,x3,x4,x5,x6; //set of basic types
797 x3:={1,2}; //change size by assignment
798 x4[1]:=3; //change size by adding element
799 x5:={}; //empty set of
800 x6[2]:=1; //out of order
801 if (sizeof(x1)==2) {setverdict(pass);} //assignment at declaration
802 else {setverdict(fail);}
803 if (sizeof(x2)==2) {setverdict(pass);} //assignment later
804 else {setverdict(fail);}
805 if (sizeof(x3)==2) {setverdict(pass);} //change size by assignment
806 else {setverdict(fail);}
807 if (sizeof(x4)==2) {setverdict(pass);} //change size by adding element
808 else {setverdict(fail);}
809 if (sizeof(x5)==0) {setverdict(pass);} //empty set of
810 else {setverdict(fail);}
811 if (sizeof(x6)==3) {setverdict(pass);} //out of order
812 else {setverdict(fail);}
815 testcase setofReplace() runs on setofOper_mycomp{
816 var setofOper_mysetof1 x1:={1,2,3,4,5};
817 var setofOper_mysetof1 a:={8,8,8};
818 var setofOper_mysetof1 x2;
819 x2 := replace(x1,2,3,a);
820 if (x2 == {1,2,8,8,8}) {setverdict(pass);}
821 else {setverdict(fail);}
824 testcase setofSubstr() runs on setofOper_mycomp{
825 var setofOper_mysetof1 x1:={1,2,3,4,5};
826 var setofOper_mysetof1 x2;
827 x2 := substr(x1,2,3);
828 if (x2 == {3,4,5}) {setverdict(pass);}
829 else {setverdict(fail);}
832 type record intsetrec { setofOper_mysetof1 a }
833 type set of intsetrec intsetreclist
835 testcase setofIsvalue() runs on setofOper_mycomp {
836 var setofOper_mysetof1 v_def;
837 var setofOper_mysetof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
838 var setofOper_mysetof1 v_full := {1,2,3,4,5,6,7,8,9,10}
840 if ( isvalue(v_def) ) { setverdict(fail); } else { setverdict(pass); };
841 if ( isvalue(v_empty) ) { setverdict(fail); } else { setverdict(pass); };
842 if ( isvalue(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
843 if ( isvalue(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
844 if ( isvalue(v_full) ) { setverdict(pass); } else { setverdict(fail); };
848 if ( isvalue(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
849 if ( isvalue(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
850 if ( isvalue(v_def) ) { setverdict(fail); } else { setverdict(pass); };
853 template intsetreclist ist1 := { { a := { 1, 2, 3 } } };
854 template intsetreclist ist2 modifies ist1 := { { a := { 1, 2, -, -, -, 100 } } }
855 template intsetrec istt1 := { a := { 1, 2, 3 } }
856 template intsetrec istt2 modifies istt1 := { a := { 1, 2, -, -, -, 100 } }
858 if (isvalue (ist1)) { setverdict ( pass );
859 } else { setverdict ( fail ); }
860 if (isvalue (ist2)) { setverdict ( fail ); }
861 else { setverdict(pass); }
862 if (isvalue (istt1)) { setverdict ( pass );}
863 else { setverdict ( fail ); }
864 if (isvalue (istt2)) { setverdict ( fail ); }
865 else { setverdict(pass); }
868 testcase setofIsvalue2() runs on setofOper_mycomp {
869 var setofOper_mysetof1 v;
870 if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
873 if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
876 if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
879 if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
882 if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };
885 if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };
887 v[6] := 6; // there is now a hole at 5
888 if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
891 testcase setofIsbound() runs on setofOper_mycomp {
892 var setofOper_mysetof1 v_def;
893 var setofOper_mysetof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
894 var setofOper_mysetof1 v_full := {1,2,3,4,5,6,7,8,9,10}
896 if ( isbound(v_def) ) { setverdict(fail); } else { setverdict(pass); };
897 if ( isbound(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
898 if ( isbound(v_empty) ) { setverdict(pass); } else { setverdict(fail); };
899 if ( isbound(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
900 if ( isbound(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
901 if ( isbound(v_full) ) { setverdict(pass); } else { setverdict(fail); };
905 if ( isbound(v_def) ) { setverdict(pass); } else { setverdict(fail); };
906 if ( isbound(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
907 if ( isbound(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
908 if ( isbound(v_def[10]) ) { setverdict(fail); } else { setverdict(pass); };
911 template intsetreclist ist1 := { { a := { 1, 2, 3 } } };
912 template intsetreclist ist2 modifies ist1 := { { a := { 1, 2, -, -, -, 100 } } }
913 template intsetrec istt1 := { a := { 1, 2, 3 } }
914 template intsetrec istt2 modifies istt1 := { a := { 1, 2, -, -, -, 100 } }
916 if (isbound (ist1)) { setverdict(pass); } else { setverdict(fail); };
917 if (isbound (ist2)) { setverdict(pass); } else { setverdict(fail); };
918 if (isbound (istt1)) { setverdict(pass); } else { setverdict(fail); };
919 if (isbound (istt2)) { setverdict(pass); } else { setverdict(fail); };
922 testcase setofCompConst() runs on setofOper_mycomp{
923 const setofOper_mysetof1 c_s1 := {1,2,3,4};
924 const setofOper_mysetof1 c_s2 := {4,3,2,1};
925 const setofOper_mysetof1 c_s3 := {1,3,2,4};
926 const setofOper_mysetof1 c_s4 := {1,2,3,4,5};
927 const setofOper_mysetof1 c_s5 := {0,1,2,3,4};
928 const setofOper_mysetof1 c_s6 := {0,1,2,3,4,5}
930 const setofOper_mysetof1 c_s1_ind := {[0] := 1,[1] := 2,[2] := 3, [3] := 4};
931 const setofOper_mysetof1 c_s2_ind := {[0] := 1,[3] := 4,[2] := 3, [1] := 2};
932 const setofOper_mysetof1 c_s3_ind := {[0] := 2,[3] := 1,[2] := 3, [1] := 4};
934 var setofOper_mysetof1 vl_s1 := {1,2,3,4};
936 if(c_s1 == c_s1) {setverdict(pass);}
937 else {setverdict(fail);}
939 if(c_s1 == {1,2,3,4}) {setverdict(pass);}
940 else {setverdict(fail);}
942 if(c_s1 == {[0] := 1,[1] := 2,[2] := 3, [3] := 4}) {setverdict(pass);}
943 else {setverdict(fail);}
945 if(c_s1 == c_s1_ind) {setverdict(pass);}
946 else {setverdict(fail);}
948 if(c_s1_ind == c_s2_ind) {setverdict(pass);}
949 else {setverdict(fail);}
951 if(c_s1_ind == c_s3_ind) {setverdict(pass);}
952 else {setverdict(fail);}
954 if(c_s1 == c_s3_ind) {setverdict(pass);}
955 else {setverdict(fail);}
957 if(c_s2_ind == c_s3_ind) {setverdict(pass);}
958 else {setverdict(fail);}
960 if(c_s1 == vl_s1) {setverdict(pass);}
961 else {setverdict(fail);}
963 if(c_s1 == c_s2) {setverdict(pass);}
964 else {setverdict(fail);}
966 if(c_s1 == c_s3) {setverdict(pass);}
967 else {setverdict(fail);}
969 if(c_s1 != c_s4) {setverdict(pass);}
970 else {setverdict(fail);}
972 if(c_s1 != c_s5) {setverdict(pass);}
973 else {setverdict(fail);}
975 if(c_s1 != c_s6) {setverdict(pass);}
976 else {setverdict(fail);}
978 if(c_s5 != c_s6) {setverdict(pass);}
979 else {setverdict(fail);}
983 type set length(5) of set length(6) of charstring StringSetArray length(12)
984 type set length(4) of charstring MySetof1 length(2)
985 type set of charstring MySetof2 ("a", "aa", "aaa", "aaaa") length(2)
986 type set length(2) of charstring MySetof3 ("a", "aa", "aaa", "aaaa")
987 type set length(2) of charstring MySetof4 ("a", "aa", "aaa", "aaaa") length(2)
988 // TODO: Add additional subtypes here.
989 type MySetof2 MySetof5
990 type MySetof3 MySetof6
991 type MySetof4 MySetof7
992 type set of record { charstring id length(2), charstring val length(2) } GenericParameters1
993 type GenericParameters1[-] GenericParameters2 ({"aa", "aa"})
994 type GenericParameters1[-] GenericParameters3 ({"aa", "aa"})
995 // FATAL_ERROR() with R8B: `const GenericParameters1[-] c_pars1 := {c_mysetof6[0], valueof(t_mysetof7[0])}'.
996 // Possibly the same FATAL_ERROR(): `template MySetof2 t_mysetof8 := {"aa", t_mysetof7[0]} length(2)'.
997 // `MySetof2' doesn't have a subtype? `type MySetof2 MySetof8 (MySetof2)'
998 type MySetof3 MySetof8 (MySetof3, MySetof3, MySetof3)
1000 const MySetof2 c_mysetof1 := {}
1001 const MySetof2 c_mysetof2 := {"aa", "aa"}
1002 const MySetof2 c_mysetof3 := {c_mysetof2[0], c_mysetof2[1]}
1003 const MySetof3 c_mysetof4 := {"a", "aa"}
1004 const MySetof3 c_mysetof5 := {c_mysetof4[0], c_mysetof4[1]}
1005 const MySetof4 c_mysetof6 := {"aa", "aa"}
1006 const MySetof4 c_mysetof7 := {c_mysetof6[0], c_mysetof6[1]}
1008 template MySetof2 t_mysetof1 := {}
1009 template MySetof2 t_mysetof2 := {"aa", "aa"}
1010 template MySetof2 t_mysetof3 := c_mysetof2
1011 template MySetof3 t_mysetof4 := {"a", "aa"}
1012 template MySetof3 t_mysetof5 := c_mysetof5
1013 template MySetof4 t_mysetof6 := {"aa", "aa"}
1014 template MySetof4 t_mysetof7 := c_mysetof7
1015 template MySetof2 t_mysetof8 := {"aa", c_mysetof7[0]} length(2)
1016 template MySetof8 t_mysetof9 := {"aa" & "aa", "aa"}
1018 testcase setofSubtypes() runs on setofOper_mycomp {
1019 var template MySetof1 vt_mysetof1 := {"AA", "AB", "BA", "BB"}
1020 var MySetof1 v_mysetof1 := {"AA", "AB", "BA", "BB"}
1021 // TITAN compiles this.
1022 if (substr(v_mysetof1, 0, 2) == {"AA", "AB"} and {"BA", "BB"} == substr(valueof(vt_mysetof1), 2, 2)) { setverdict(pass) }
1023 else { setverdict(fail) }
1027 const setofOper_trecord cl_temp1:={ x1:=omit, x2:=3.4 }; //constant in control part
1028 const setofOper_trecof cl_temp2:={ 'AF12'O };
1029 const setofOper_tset cl_temp3:={ x1:=234, x2:=1.9};
1030 const setofOper_tsetof cl_temp4:={"f","8"};
1031 const setofOper_tunion cl_temp5:={ x2:=1.3 };
1032 var setofOper_trecord vl_temp1; //variable in control part
1033 var setofOper_trecof vl_temp2;
1034 var setofOper_tset vl_temp3;
1035 var setofOper_tsetof vl_temp4;
1036 var setofOper_tunion vl_temp5;
1038 execute(setofAssign());
1039 execute(setofAssignEnum());
1040 execute(setofAssignRec());
1041 execute(setofAssignRecof());
1042 execute(setofAssignSet());
1043 execute(setofAssignSetof());
1044 execute(setofAssignUnion());
1045 execute(setofAssignElem());
1046 execute(setofAssignElemEnum());
1047 execute(setofAssignElemRec());
1048 execute(setofAssignElemRecof());
1049 execute(setofAssignElemSet());
1050 execute(setofAssignElemSetof());
1051 execute(setofAssignElemUnion());
1052 execute(setofConst());
1053 execute(setofConstEnum());
1054 execute(setofConstRec());
1055 execute(setofConstRecof());
1056 execute(setofConstSet());
1057 execute(setofConstSetof());
1058 execute(setofConstUnion());
1059 execute(setofConstComp());
1060 execute(setofComp());
1061 execute(setofCompConst());
1062 execute(setofCompEnum());
1063 execute(setofCompRec());
1064 execute(setofCompRecof());
1065 execute(setofCompSet());
1066 execute(setofCompSetof());
1067 execute(setofCompUnion());
1068 execute(setofCompUnbound());
1069 execute(setofListOperator());
1070 execute(setofRotateOperators());
1071 execute(setofLengthof());
1072 execute(setofSizeof());
1073 execute(setofReplace());
1074 execute(setofSubstr());
1075 execute(setofIsvalue());
1076 execute(setofIsvalue2());
1077 execute(setofIsbound());
1080 execute(setofSubtypes());