Commit | Line | Data |
---|---|---|
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 | ******************************************************************************/ | |
8 | module TsetofOper { | |
9 | // ********** Type definitions ********************* | |
10 | type component setofOper_mycomp {}; | |
11 | type enumerated setofOper_myenum {xx1,xx2,xx3}; | |
12 | type record setofOper_trecord { | |
13 | integer x1 optional, | |
14 | float x2 }; | |
15 | type record of octetstring setofOper_trecof; | |
16 | type set setofOper_tset { | |
17 | integer x1, | |
18 | float x2 optional }; | |
19 | type set of charstring setofOper_tsetof; | |
20 | type union setofOper_tunion { | |
21 | integer x1, | |
22 | float x2 }; | |
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 } | |
48 | ||
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; | |
52 | x2:={ 32, 12 }; | |
53 | x3:={32}; | |
54 | x3:={32,12}; | |
55 | 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);} | |
70 | } | |
71 | ||
72 | testcase setofAssignEnum() runs on setofOper_mycomp{ | |
73 | var setofOper_mysetof2 x1:={ xx2 } //set of enum | |
74 | var setofOper_mysetof2 x2; | |
75 | x2:={xx2,xx1}; | |
76 | //at declaration | |
77 | if (x1[0]==xx2) {setverdict(pass);} | |
78 | else {setverdict(fail);} | |
79 | //later | |
80 | if (x2[0]==xx2) {setverdict(pass);} | |
81 | else {setverdict(fail);} | |
82 | if (x2[1]==xx1) {setverdict(pass);} | |
83 | else {setverdict(fail);} | |
84 | } | |
85 | ||
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);} | |
106 | } | |
107 | ||
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);} | |
126 | } | |
127 | ||
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);} | |
148 | } | |
149 | ||
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);} | |
170 | } | |
171 | ||
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);} | |
198 | } | |
199 | ||
200 | testcase setofAssignElem() runs on setofOper_mycomp{ | |
201 | var setofOper_mysetof1 x1,x2,x3,x4,x5; //set of basic types | |
202 | x1:={ 3, 2 }; | |
203 | x2:={ 1, 2 }; | |
204 | x3:=x2; | |
205 | x4:=x2; | |
206 | x5:={2}; | |
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);} | |
229 | } | |
230 | ||
231 | testcase setofAssignElemEnum() runs on setofOper_mycomp{ | |
232 | var setofOper_mysetof2 x1:={ xx1, xx2 }; //set of enumerated | |
233 | var setofOper_mysetof2 x2, x3; | |
234 | x2:={ xx1, xx2 } | |
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);} | |
250 | } | |
251 | ||
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 } }; | |
255 | x2:=x1; | |
256 | x1[0].x1:=2; | |
257 | //temp1.x1:=3; | |
258 | x1[1].x1:=3; | |
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);} | |
285 | } | |
286 | ||
287 | ||
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 } }; | |
291 | x2:=x1; | |
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);} | |
311 | } | |
312 | ||
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);} | |
344 | } | |
345 | ||
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);} | |
370 | } | |
371 | ||
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);} | |
416 | } | |
417 | ||
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);} | |
430 | } | |
431 | ||
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);} | |
444 | } | |
445 | ||
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);} | |
461 | } | |
462 | ||
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);} | |
478 | } | |
479 | ||
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);} | |
495 | } | |
496 | ||
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);} | |
514 | } | |
515 | ||
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);} | |
539 | } | |
540 | ||
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);} | |
558 | } | |
559 | ||
560 | testcase setofComp() runs on setofOper_mycomp{ | |
561 | var setofOper_mysetof1 x1,x2,x3,x4; //set of basic types | |
562 | x1:={ 1,2,3 }; | |
563 | x2:={ 1,2,3 }; | |
564 | x3:={ 1,2 }; | |
565 | x4:={ 3,1,2 }; | |
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);} | |
578 | } | |
579 | ||
580 | testcase setofCompEnum() runs on setofOper_mycomp{ | |
581 | var setofOper_mysetof2 x1,x2,x3,x4; //set of enumerated | |
582 | x1:={ xx1,xx2,xx3 }; | |
583 | x2:={ xx1,xx2,xx3 }; | |
584 | x3:={ xx1,xx2 }; | |
585 | x4:={xx3,xx2,xx1}; | |
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);} | |
598 | } | |
599 | ||
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);} | |
618 | } | |
619 | ||
620 | ||
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);} | |
639 | } | |
640 | ||
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);} | |
660 | } | |
661 | ||
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);} | |
681 | } | |
682 | ||
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);} | |
702 | } | |
703 | ||
704 | //TR HP50388: | |
705 | testcase setofCompUnbound() runs on setofOper_mycomp{ | |
706 | var setofOper_mysetof1 x1,x2,x3,x4; | |
707 | x1 := {[3] := 4}; | |
708 | x2 := {[3] := 4}; | |
709 | x3 := {-,-,-,4}; | |
710 | x4 := {-,4,-,-}; | |
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);} | |
717 | } | |
718 | ||
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; | |
723 | x2:={ 1, 2 }; | |
724 | x3:={1}; | |
725 | x4:={1}; | |
726 | x4[1]:=3; | |
727 | x5:={}; | |
728 | x6[2]:=1; | |
729 | res1 := x1 & x2; | |
730 | res2 := x1 & x3; | |
731 | res3 := x2 & x3 & x5; | |
732 | res4 := x3 & x4; | |
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);} | |
741 | } | |
742 | ||
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 | |
746 | x2 := x1 <@ 1; | |
747 | x3 := x1 <@ 10; | |
748 | x4 := x1 <@ 3 <@ 2; | |
749 | x5 := x1 @> 1; | |
750 | x6 := x1 @> 10; | |
751 | x7 := x1 @> 3 @> 2; | |
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);} | |
764 | } | |
765 | ||
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 | |
770 | x2:={ 1, 2 }; | |
771 | x3:={1}; | |
772 | x4:={1}; | |
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);} | |
789 | } | |
790 | ||
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 | |
794 | x2:={ 1, 2 }; | |
795 | x3:={1}; | |
796 | x4:={1}; | |
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);} | |
813 | } | |
814 | ||
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);} | |
822 | } | |
823 | ||
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);} | |
830 | } | |
831 | ||
832 | type record intsetrec { setofOper_mysetof1 a } | |
833 | type set of intsetrec intsetreclist | |
834 | ||
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} | |
839 | ||
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); }; | |
845 | ||
846 | v_def[1] := 3; | |
847 | ||
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); }; | |
851 | ||
852 | ||
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 } } | |
857 | ||
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); } | |
866 | } | |
867 | ||
868 | testcase setofIsvalue2() runs on setofOper_mycomp { | |
869 | var setofOper_mysetof1 v; | |
870 | if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); }; | |
871 | ||
872 | v[3] := 3; | |
873 | if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); }; | |
874 | ||
875 | v[2] := 2; | |
876 | if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); }; | |
877 | ||
878 | v[1] := 1; | |
879 | if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); }; | |
880 | ||
881 | v[0] := 0; | |
882 | if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); }; | |
883 | ||
884 | v[4] := 4; | |
885 | if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); }; | |
886 | ||
887 | v[6] := 6; // there is now a hole at 5 | |
888 | if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); }; | |
889 | } | |
890 | ||
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} | |
895 | ||
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); }; | |
902 | ||
903 | v_def[1] := 3; | |
904 | ||
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); }; | |
909 | ||
910 | ||
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 } } | |
915 | ||
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); }; | |
920 | } | |
921 | ||
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} | |
929 | ||
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}; | |
933 | ||
934 | var setofOper_mysetof1 vl_s1 := {1,2,3,4}; | |
935 | ||
936 | if(c_s1 == c_s1) {setverdict(pass);} | |
937 | else {setverdict(fail);} | |
938 | ||
939 | if(c_s1 == {1,2,3,4}) {setverdict(pass);} | |
940 | else {setverdict(fail);} | |
941 | ||
942 | if(c_s1 == {[0] := 1,[1] := 2,[2] := 3, [3] := 4}) {setverdict(pass);} | |
943 | else {setverdict(fail);} | |
944 | ||
945 | if(c_s1 == c_s1_ind) {setverdict(pass);} | |
946 | else {setverdict(fail);} | |
947 | ||
948 | if(c_s1_ind == c_s2_ind) {setverdict(pass);} | |
949 | else {setverdict(fail);} | |
950 | ||
951 | if(c_s1_ind == c_s3_ind) {setverdict(pass);} | |
952 | else {setverdict(fail);} | |
953 | ||
954 | if(c_s1 == c_s3_ind) {setverdict(pass);} | |
955 | else {setverdict(fail);} | |
956 | ||
957 | if(c_s2_ind == c_s3_ind) {setverdict(pass);} | |
958 | else {setverdict(fail);} | |
959 | ||
960 | if(c_s1 == vl_s1) {setverdict(pass);} | |
961 | else {setverdict(fail);} | |
962 | ||
963 | if(c_s1 == c_s2) {setverdict(pass);} | |
964 | else {setverdict(fail);} | |
965 | ||
966 | if(c_s1 == c_s3) {setverdict(pass);} | |
967 | else {setverdict(fail);} | |
968 | ||
969 | if(c_s1 != c_s4) {setverdict(pass);} | |
970 | else {setverdict(fail);} | |
971 | ||
972 | if(c_s1 != c_s5) {setverdict(pass);} | |
973 | else {setverdict(fail);} | |
974 | ||
975 | if(c_s1 != c_s6) {setverdict(pass);} | |
976 | else {setverdict(fail);} | |
977 | ||
978 | if(c_s5 != c_s6) {setverdict(pass);} | |
979 | else {setverdict(fail);} | |
980 | ||
981 | } | |
982 | ||
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) | |
999 | ||
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]} | |
1007 | ||
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"} | |
1017 | ||
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) } | |
1024 | } | |
1025 | ||
1026 | control { | |
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; | |
1037 | ||
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()); | |
1078 | ||
1079 | ||
1080 | execute(setofSubtypes()); | |
1081 | ||
1082 | ||
1083 | } | |
1084 | ||
1085 | } |