projects / deliverable / titan.core.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Sync with 5.4.0
[deliverable/titan.core.git] / regression_test / bitstrOper / TbitstrOper.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 TbitstrOper
9{ type component bitstrOper_comptype { };
10const bitstring TbitstrOper_const1:='1000'B;
11
12testcase bitstrAssign() runs on bitstrOper_comptype
13{ var bitstring x1:='01101'B;
14 var bitstring x2,x3,x4;
15 x2:='0111'B;
16 x4:='01'B;
17 x3:=''B;
18 x4:='0101'B;
19 if (x1=='01101'B) {setverdict(pass);} //at declaration
20 else {setverdict(fail);}
21 if (x2=='0111'B) {setverdict(pass);} //later
22 else {setverdict(fail);}
23 if (x3==''B) {setverdict(pass);} //empty string
24 else {setverdict(fail);}
25 if (x4=='0101'B) {setverdict(pass);} //change of size
26 else {setverdict(fail);}
27}
28
29testcase bitstrAssignElem10() runs on bitstrOper_comptype
30{ var bitstring x1,x2,x3,x4,x5,x6;
31 x1:='11111'B;
32 x4:='11111'B;
33 x2:='00000'B;
34 x5:='11111'B;
35 x3:='1'B;
36 x6:='0'B
37 x3:=x2[1];
38 x1[1]:='0'B;
39 x4[3]:=x2[3];
40 x5[1]:=x6;
41 if (x1[0]=='1'B) {setverdict(pass);} //accessing an element
42 else {setverdict(fail);}
43 if (x3=='0'B) {setverdict(pass);} //change string to element
44 else {setverdict(fail);}
45 if (x1=='10111'B) {setverdict(pass);} //change element to value
46 else {setverdict(fail);}
47 if (x4=='11101'B) {setverdict(pass);} //change element to element
48 else {setverdict(fail);}
49 if (x5=='10111'B) {setverdict(pass);} //change element to string
50 else {setverdict(fail);}
51}
52
53testcase bitstrAssignElem01() runs on bitstrOper_comptype
54{ var bitstring x1,x2,x3,x4,x5,x6;
55 x1:='00000'B;
56 x2:='11111'B;
57 x4:='00000'B;
58 x5:='00000'B;
59 x6:='1'B;
60 x3:='0'B;
61 x3:=x2[1];
62 x1[2]:='1'B;
63 x4[1]:=x2[4];
64 x5[1]:=x6;
65 if (x3=='1'B) {setverdict(pass);} //change string to element
66 else {setverdict(fail);}
67 if (x1=='00100'B) {setverdict(pass);} //change element to value
68 else {setverdict(fail);}
69 if (x4=='01000'B) {setverdict(pass);} //change element to element
70 else {setverdict(fail);}
71 if (x5=='01000'B) {setverdict(pass);} //change element to string
72 else {setverdict(fail);}
73}
74
75testcase bitstrAssignElem00() runs on bitstrOper_comptype
76{ var bitstring x1,x2,x3,x4,x5,x6;
77 x1:='00000'B;
78 x2:='00000'B;
79 x4:='00000'B;
80 x5:='00000'B;
81 x6:='0'B;
82 x3:='0'B;
83 x3:=x2[1];
84 x1[2]:='0'B;
85 x4[1]:=x2[4];
86 x5[1]:=x6;
87 if (x3=='0'B) {setverdict(pass);} //change string to element
88 else {setverdict(fail);}
89 if (x1=='00000'B) {setverdict(pass);} //change element to value
90 else {setverdict(fail);}
91 if (x4=='00000'B) {setverdict(pass);} //change element to element
92 else {setverdict(fail);}
93 if (x5=='00000'B) {setverdict(pass);} //change element to string
94 else {setverdict(fail);}
95}
96
97testcase bitstrAssignElem11() runs on bitstrOper_comptype
98{ var bitstring x1,x2,x3,x4,x5,x6;
99 x1:='11111'B;
100 x2:='11111'B;
101 x4:='11111'B;
102 x5:='11111'B;
103 x6:='1'B;
104 x3:='1'B;
105 x3:=x2[1];
106 x1[2]:='1'B;
107 x4[1]:=x2[4];
108 x5[1]:=x6;
109 if (x3=='1'B) {setverdict(pass);} //change string to element
110 else {setverdict(fail);}
111 if (x1=='11111'B) {setverdict(pass);} //change element to value
112 else {setverdict(fail);}
113 if (x4=='11111'B) {setverdict(pass);} //change element to element
114 else {setverdict(fail);}
115 if (x5=='11111'B) {setverdict(pass);} //change element to string
116 else {setverdict(fail);}
117}
118
119testcase bitstrAssignElemAdd() runs on bitstrOper_comptype
120{var bitstring x1,x2;
121 x1:='000'B;
122 x2:='1111'B;
123 x1[3]:='1'B;
124 x2[4]:=x1[0];
125 if (x1=='0001'B) {setverdict(pass);} //add "1"
126 else {setverdict(fail);}
127 if (x2=='11110'B) {setverdict(pass);} //add "0"
128 else {setverdict(fail);}
129}
130
131testcase bitstrLengthof() runs on bitstrOper_comptype
132{ var bitstring x1:='01101'B;
133 var bitstring x2,x3,x4,x5;
134 x2:='0111'B;
135 x4:='01'B;
136 x5:='01'B;
137 x3:=''B;
138 x4:='0101'B;
139 x5[2]:='0'B;
140 if (lengthof(x1)==5) {setverdict(pass);} //at declaration
141 else {setverdict(fail);}
142 if (lengthof(x2)==4) {setverdict(pass);} //later
143 else {setverdict(fail);}
144 if (lengthof(x3)==0) {setverdict(pass);} //empty string
145 else {setverdict(fail);}
146 if (lengthof(x4)==4) {setverdict(pass);} //change of size
147 else {setverdict(fail);}
148 if (lengthof(x5)==3) {setverdict(pass);} //add element
149 else {setverdict(fail);}
150}
151
152testcase bitstrConst() runs on bitstrOper_comptype
153{const bitstring TbitstrOper_const3:='0001'B;
154 if (TbitstrOper_const1=='1000'B) {setverdict(pass);} //definition part
155 else {setverdict(fail);}
156 if (TbitstrOper_const3=='0001'B) {setverdict(pass);} //testcase
157 else {setverdict(fail);}
158}
159
160testcase bitstrComp_str_str() runs on bitstrOper_comptype
161{var bitstring x1,x2,x3;
162 x1:='0110'B;
163 x2:='0110'B;
164 x3:='011'B;
165 if (x1==x2) {setverdict(pass);} //equality, equals
166 else {setverdict(fail);}
167 if (not(x3==x2)) {setverdict(pass);} //equality, not equals
168 else {setverdict(fail);}
169 if (x1!=x3) {setverdict(pass);} //non-equality, not equals
170 else {setverdict(fail);}
171 if (not(x1!=x2)) {setverdict(pass);} //non-equality, equals
172 else {setverdict(fail);}
173}
174
175testcase bitstrComp_el_str() runs on bitstrOper_comptype
176{var bitstring x1,x2,x3;
177 x1:='0110'B;
178 x2:='1'B;
179 x3:='0'B;
180 if (x1[2]==x2) {setverdict(pass);} //equality, equals
181 else {setverdict(fail);}
182 if (not(x1[2]==x3)) {setverdict(pass);} //equality, not equals
183 else {setverdict(fail);}
184 if (x1[1]!=x3) {setverdict(pass);} //non-equality, not equals
185 else {setverdict(fail);}
186 if (not(x1[1]!='1'B)) {setverdict(pass);} //non-equality, equals
187 else {setverdict(fail);}
188}
189
190testcase bitstrComp_str_el() runs on bitstrOper_comptype
191{var bitstring x1,x2,x3;
192 x1:='0110'B;
193 x2:='1'B;
194 x3:='0'B;
195 if (x2==x1[1]) {setverdict(pass);} //equality, equals
196 else {setverdict(fail);}
197 if (not(x3==x1[1])) {setverdict(pass);} //equality, not equals
198 else {setverdict(fail);}
199 if (x2!=x1[0]) {setverdict(pass);} //non-equality, not equals
200 else {setverdict(fail);}
201 if (not('1'B!=x1[1])) {setverdict(pass);} //non-equality, equals
202 else {setverdict(fail);}
203}
204
205testcase bitstrComp_el_el() runs on bitstrOper_comptype
206{var bitstring x1,x2,x3;
207 x1:='0110'B;
208 x2:='0110'B;
209 x3:='011'B;
210 if (x1[2]==x2[2]) {setverdict(pass);} //equality, equals
211 else {setverdict(fail);}
212 if (not(x1[2]==x2[3])) {setverdict(pass);} //equality, not equals
213 else {setverdict(fail);}
214 if (x1[1]!=x3[0]) {setverdict(pass);} //non-equality, not equals
215 else {setverdict(fail);}
216 if (not(x1[1]!=x3[1])) {setverdict(pass);} //non-equality, equals
217 else {setverdict(fail);}
218}
219
220testcase bitstrConcat() runs on bitstrOper_comptype
221{var bitstring x1,x2,x3,x4,x5,x6,x7,x8;
222 x1:='0011'B;
223 x2:='1100'B;
224 x3:= x1 & x2;
225 x4:=x1&x2[3];
226 x5:=x1[1]&x2;
227 x6:=x1[2]&x2[1];
228 x7:='11111111000000001111111'B;
229 x8:=x1[0]&x7;
230 if ((x3=='00111100'B)and(lengthof(x3)==8)) {setverdict(pass);} //string_string
231 else {setverdict(fail);}
232 if ((x4=='00110'B)and(lengthof(x4)==5)) {setverdict(pass);} //string_element
233 else {setverdict(fail);}
234 if ((x5=='01100'B)and(lengthof(x5)==5)) {setverdict(pass);} //element_string
235 else {setverdict(fail);}
236 if ((x6=='11'B)and(lengthof(x6)==2)) {setverdict(pass);} //element_element
237 else {setverdict(fail);}
238 if((x8=='011111111000000001111111'B)and(lengthof(x8)==24)) {setverdict(pass);}
239 else {setverdict(fail);}
240}
241
242testcase bitstrNot_str() runs on bitstrOper_comptype
243{ var bitstring x1,x2;
244 x1:='01101'B;
245 x2:=not4b(x1);
246 if (x2=='10010'B) {setverdict(pass);}
247 else {setverdict(fail);}
248 log(not4b(x1)); // HQ51603: the generated C++ must compile
249 action(not4b(x1)); // HQ51603
250}
251
252testcase bitstrNot_el() runs on bitstrOper_comptype
253{ var bitstring x1,x2,x3;
254 x1:='00111'B;
255 x2:=not4b(x1[1]);
256 x3:=not4b(x1[3]);
257 if (x2=='1'B) {setverdict(pass);} //not "0"
258 else {setverdict(fail);}
259 if (x3=='0'B) {setverdict(pass);} //not "1"
260 else {setverdict(fail);}
261}
262
263testcase bitstrAnd_str_str() runs on bitstrOper_comptype
264{ var bitstring x1,x2,x3;
265 x1:='01101'B;
266 x2:='00111'B;
267 x3:=x1 and4b x2;
268 if (x3=='00101'B) {setverdict(pass);}
269 else {setverdict(fail);}
270}
271
272testcase bitstrAnd_el_str() runs on bitstrOper_comptype
273{ var bitstring x1,x2,x3,x4,x5,x6;
274 x1:='0011'B;
275 x2:='1'B;
276 x3:=x1[0] and4b '0'B;
277 x4:=x1[0] and4b x2;
278 x5:=x1[2] and4b '0'B;
279 x6:=x1[3] and4b x2;
280 if (x3=='0'B) {setverdict(pass);} //"0" and "0"
281 else {setverdict(fail);}
282 if (x4=='0'B) {setverdict(pass);} //"0" and "1"
283 else {setverdict(fail);}
284 if (x5=='0'B) {setverdict(pass);} //"1" and "0"
285 else {setverdict(fail);}
286 if (x6=='1'B) {setverdict(pass);} //"1" and "1"
287 else {setverdict(fail);}
288}
289
290testcase bitstrAnd_str_el() runs on bitstrOper_comptype
291{ var bitstring x1,x2,x3,x4,x5,x6;
292 x1:='0011'B;
293 x2:='1'B;
294 x3:='0'B and4b x1[0];
295 x4:=x2 and4b x1[1];
296 x5:='0'B and4b x1[2];
297 x6:=x2 and4b x1[3];
298 if (x3=='0'B) {setverdict(pass);} //"0" and "0"
299 else {setverdict(fail);}
300 if (x4=='0'B) {setverdict(pass);} //"0" and "1"
301 else {setverdict(fail);}
302 if (x5=='0'B) {setverdict(pass);} //"1" and "0"
303 else {setverdict(fail);}
304 if (x6=='1'B) {setverdict(pass);} //"1" and "1"
305 else {setverdict(fail);}
306}
307
308testcase bitstrAnd_el_el() runs on bitstrOper_comptype
309{ var bitstring x1,x2,x3,x4,x5,x6;
310 x1:='0011'B;
311 x2:='0011'B;
312 x3:=x2[0] and4b x1[0];
313 x4:=x2[1] and4b x1[3];
314 x5:=x1[3] and4b x1[0];
315 x6:=x2[3] and4b x1[3];
316 if (x3=='0'B) {setverdict(pass);} //"0" and "0"
317 else {setverdict(fail);}
318 if (x4=='0'B) {setverdict(pass);} //"0" and "1"
319 else {setverdict(fail);}
320 if (x5=='0'B) {setverdict(pass);} //"1" and "0"
321 else {setverdict(fail);}
322 if (x6=='1'B) {setverdict(pass);} //"1" and "1"
323 else {setverdict(fail);}
324}
325
326testcase bitstrOr_str_str() runs on bitstrOper_comptype
327{ var bitstring x1,x2,x3;
328 x1:='01101'B;
329 x2:='00111'B;
330 x3:=x1 or4b x2;
331 if (x3=='01111'B) {setverdict(pass);}
332 else {setverdict(fail);}
333}
334
335testcase bitstrOr_el_str() runs on bitstrOper_comptype
336{ var bitstring x1,x2,x3,x4,x5,x6;
337 x1:='0011'B;
338 x2:='1'B;
339 x3:=x1[0] or4b '0'B;
340 x4:=x1[0] or4b x2;
341 x5:=x1[2] or4b '0'B;
342 x6:=x1[3] or4b x2;
343 if (x3=='0'B) {setverdict(pass);} //"0" or "0"
344 else {setverdict(fail);}
345 if (x4=='1'B) {setverdict(pass);} //"0" or "1"
346 else {setverdict(fail);}
347 if (x5=='1'B) {setverdict(pass);} //"1" or "0"
348 else {setverdict(fail);}
349 if (x6=='1'B) {setverdict(pass);} //"1" or "1"
350 else {setverdict(fail);}
351}
352
353testcase bitstrOr_str_el() runs on bitstrOper_comptype
354{ var bitstring x1,x2,x3,x4,x5,x6;
355 x1:='0011'B;
356 x2:='1'B;
357 x3:='0'B or4b x1[0];
358 x4:=x2 or4b x1[1];
359 x5:='0'B or4b x1[2];
360 x6:=x2 or4b x1[3];
361 if (x3=='0'B) {setverdict(pass);} //"0" or "0"
362 else {setverdict(fail);}
363 if (x4=='1'B) {setverdict(pass);} //"0" or "1"
364 else {setverdict(fail);}
365 if (x5=='1'B) {setverdict(pass);} //"1" or "0"
366 else {setverdict(fail);}
367 if (x6=='1'B) {setverdict(pass);} //"1" or "1"
368 else {setverdict(fail);}
369}
370
371testcase bitstrOr_el_el() runs on bitstrOper_comptype
372{ var bitstring x1,x2,x3,x4,x5,x6;
373 x1:='0011'B;
374 x2:='0011'B;
375 x3:=x2[0] or4b x1[0];
376 x4:=x2[1] or4b x1[3];
377 x5:=x1[3] or4b x1[0];
378 x6:=x2[3] or4b x1[3];
379 if (x3=='0'B) {setverdict(pass);} //"0" or "0"
380 else {setverdict(fail);}
381 if (x4=='1'B) {setverdict(pass);} //"0" or "1"
382 else {setverdict(fail);}
383 if (x5=='1'B) {setverdict(pass);} //"1" or "0"
384 else {setverdict(fail);}
385 if (x6=='1'B) {setverdict(pass);} //"1" or "1"
386 else {setverdict(fail);}
387}
388
389testcase bitstrXor_str_str() runs on bitstrOper_comptype
390{ var bitstring x1,x2,x3;
391 x1:='01101'B;
392 x2:='00111'B;
393 x3:=x1 xor4b x2;
394 if (x3=='01010'B) {setverdict(pass);}
395 else {setverdict(fail);}
396}
397
398testcase bitstrXor_el_str() runs on bitstrOper_comptype
399{ var bitstring x1,x2,x3,x4,x5,x6;
400 x1:='0011'B;
401 x2:='1'B;
402 x3:=x1[0] xor4b '0'B;
403 x4:=x1[0] xor4b x2;
404 x5:=x1[2] xor4b '0'B;
405 x6:=x1[3] xor4b x2;
406 if (x3=='0'B) {setverdict(pass);} //"0" xor "0"
407 else {setverdict(fail);}
408 if (x4=='1'B) {setverdict(pass);} //"0" xor "1"
409 else {setverdict(fail);}
410 if (x5=='1'B) {setverdict(pass);} //"1" xor "0"
411 else {setverdict(fail);}
412 if (x6=='0'B) {setverdict(pass);} //"1" xor "1"
413 else {setverdict(fail);}
414}
415
416testcase bitstrXor_str_el() runs on bitstrOper_comptype
417{ var bitstring x1,x2,x3,x4,x5,x6;
418 x1:='0011'B;
419 x2:='1'B;
420 x3:='0'B xor4b x1[0];
421 x4:=x2 xor4b x1[1];
422 x5:='0'B xor4b x1[2];
423 x6:=x2 xor4b x1[3];
424 if (x3=='0'B) {setverdict(pass);} //"0" xor "0"
425 else {setverdict(fail);}
426 if (x4=='1'B) {setverdict(pass);} //"0" xor "1"
427 else {setverdict(fail);}
428 if (x5=='1'B) {setverdict(pass);} //"1" xor "0"
429 else {setverdict(fail);}
970ed795
EL		 430 if (x6=='0'B) {setverdict(pass);} //"1" xor "1"
431 else {setverdict(fail);}
432}
433
434testcase bitstrXor_el_el() runs on bitstrOper_comptype
435{ var bitstring x1,x2,x3,x4,x5,x6;
436 x1:='0011'B;
437 x2:='0011'B;
438 x3:=x2[0] xor4b x1[0];
439 x4:=x2[1] xor4b x1[3];
440 x5:=x1[3] xor4b x1[0];
441 x6:=x2[3] xor4b x1[3];
442 if (x3=='0'B) {setverdict(pass);} //"0" xor "0"
443 else {setverdict(fail);}
444 if (x4=='1'B) {setverdict(pass);} //"0" xor "1"
445 else {setverdict(fail);}
446 if (x5=='1'B) {setverdict(pass);} //"1" xor "0"
447 else {setverdict(fail);}
448 if (x6=='0'B) {setverdict(pass);} //"1" xor "1"
449 else {setverdict(fail);}
450}
451
452testcase bitstrShiftRight1() runs on bitstrOper_comptype
453{ var bitstring x1,x2;
454 x1:='01101'B;
455 x2:=x1 >> 1;
456 if (x2=='00110'B) {setverdict(pass);}
457 else {setverdict(fail);}
458}
459
460testcase bitstrShiftRight2() runs on bitstrOper_comptype
461{ var bitstring x1,x2;
462 x1:='01101'B;
463 x2:=x1 >> 2;
464 if (x2=='00011'B) {setverdict(pass);}
465 else {setverdict(fail);}
466}
467
468testcase bitstrShiftRightSum() runs on bitstrOper_comptype
469{ var bitstring x1,x2;
470 x1:='01101'B;
471 x2:=x1 >> (1+1);
472 if (x2=='00011'B) {setverdict(pass);}
473 else {setverdict(fail);}
474}
475
476testcase bitstrShiftRightEmpty() runs on bitstrOper_comptype
477{ var bitstring x1,x2;
478 x1:=''B;
479 x2:=x1 >> 1;
480 if (x2==''B) {setverdict(pass);}
481 else {setverdict(fail);}
482}
483
484testcase bitstrShiftLeft1() runs on bitstrOper_comptype
485{ var bitstring x1,x2;
486 x1:='01101'B;
487 x2:=x1 << 1;
488 if (x2=='11010'B) {setverdict(pass);}
489 else {setverdict(fail);}
490}
491
492testcase bitstrShiftLeft2() runs on bitstrOper_comptype
493{ var bitstring x1,x2;
494 x1:='01101'B;
495 x2:=x1 << 2;
496 if (x2=='10100'B) {setverdict(pass);}
497 else {setverdict(fail);}
498}
499
500testcase bitstrShiftLeftSum() runs on bitstrOper_comptype
501{ var bitstring x1,x2;
502 x1:='01101'B;
503 x2:=x1 << (1+1);
504 if (x2=='10100'B) {setverdict(pass);}
505 else {setverdict(fail);}
506}
507
508testcase bitstrShiftLeftEmpty() runs on bitstrOper_comptype
509{ var bitstring x1,x2;
510 x1:=''B;
511 x2:=x1 << 1;
512 if (x2==''B) {setverdict(pass);}
513 else {setverdict(fail);}
514}
515
516testcase bitstrRotateRight1() runs on bitstrOper_comptype
517{ var bitstring x1,x2;
518 x1:='01101'B;
519 x2:=x1 @> 1;
520 if (x2=='10110'B) {setverdict(pass);}
521 else {setverdict(fail);}
522}
523
524testcase bitstrRotateRight2() runs on bitstrOper_comptype
525{ var bitstring x1,x2;
526 x1:='01101'B;
527 x2:=x1 @> 2;
528 if (x2=='01011'B) {setverdict(pass);}
529 else {setverdict(fail);}
530}
531
532testcase bitstrRotateRightSum() runs on bitstrOper_comptype
533{ var bitstring x1,x2;
534 x1:='01101'B;
535 x2:=x1 @> (1+1);
536 if (x2=='01011'B) {setverdict(pass);}
537 else {setverdict(fail);}
538}
539
540testcase bitstrRotateRightEmpty() runs on bitstrOper_comptype
541{ var bitstring x1,x2;
542 x1:=''B;
543 x2:=x1 @> 1;
544 if (x2==''B) {setverdict(pass);}
545 else {setverdict(fail);}
546}
547
548testcase bitstrRotateLeft1() runs on bitstrOper_comptype
549{ var bitstring x1,x2;
550 x1:='01101'B;
551 x2:=x1 <@ 1;
552 if (x2=='11010'B) {setverdict(pass);}
553 else {setverdict(fail);}
554}
555
556testcase bitstrRotateLeft2() runs on bitstrOper_comptype
557{ var bitstring x1,x2;
558 x1:='01101'B;
559 x2:=x1 <@ 2;
560 if (x2=='10101'B) {setverdict(pass);}
561 else {setverdict(fail);}
562}
563
564testcase bitstrRotateLeftSum() runs on bitstrOper_comptype
565{ var bitstring x1,x2;
566 x1:='01101'B;
567 x2:=x1 <@ (1+1);
568 if (x2=='10101'B) {setverdict(pass);}
569 else {setverdict(fail);}
570}
571
572testcase bitstrRotateLeftEmpty() runs on bitstrOper_comptype
573{ var bitstring x1,x2;
574 x1:=''B;
575 x2:=x1 <@ 1;
576 if (x2==''B) {setverdict(pass);}
577 else {setverdict(fail);}
578}
579
580type bitstring mybstr1
581type mybstr1 mybstr2
582type mybstr1 mybstr3 ('0'B, '1'B)
583type mybstr1 mybstr4 ('0'B, '1'B) length(1)
584type mybstr1 mybstr5 length(1)
585type mybstr1 mybstr6 (int2bit(512, 11), int2bit(1024, 11))
586// Length 0.
587type bitstring mybstr7 length(0..0)
588type bitstring MyByte length(8..8)
589type bitstring MyNibbleToByte length(4..8)
590type bitstring BitStrings1 ('0'B, '1'B)
591type bitstring BitStrings2 ('00'B, '01'B, '10'B, '10'B)
592type bitstring BitStrings_1_2 (BitStrings1, BitStrings2)
593type bitstring mybstr8 (mybstr3, mybstr4)
594type bitstring mybstr9 length(0..infinity) // Full set.
595
596const mybstr4 c_mybstr1 := '0'B
597const mybstr8 c_mybstr2 := c_mybstr1
598
599template mybstr4 t_mybstr1 := '0'B
600template mybstr8 t_mybstr2 := t_mybstr1
601template mybstr7 t_mybstr3 := ''B length(0)
602
603function f_bstr1() return mybstr3 {
604 var mybstr2 v_mybstr1 := int2bit(bit2int('0'B), 1)
605 var template mybstr4 vt_mybstr1 := '1'B
606 // `vt_mybstr1[0] := '0'B' doesn't compile. T_REFD nodes were not handled
607 // in the fix for TR 921.
608 return substr(v_mybstr1 & valueof(vt_mybstr1), 0, 1)
609}
610
611testcase bitstrSubtypes(in template mybstr3 p1) runs on bitstrOper_comptype {
612 var template mybstr3 vt_mybstr1 := '0'B // Value list.
613 var template mybstr4 vt_mybstr2 := '0'B // Length with value list.
614 var template mybstr5 vt_mybstr3 := '0'B // Length only.
615 var mybstr3 v_mybstr1 := valueof(vt_mybstr1)
616 var mybstr4 v_mybstr2 := valueof(vt_mybstr2)
617 var mybstr5 v_mybstr3 := valueof(vt_mybstr3)
618
619 if (valueof(vt_mybstr1) == v_mybstr1 and v_mybstr2 == valueof(vt_mybstr2)) { setverdict(pass) }
620 else { setverdict(fail) }
621 if (valueof(vt_mybstr3) == v_mybstr3) { setverdict(pass) }
622 else { setverdict(fail) }
623 if (f_bstr1() == c_mybstr1 and '0'B == f_bstr1()) { setverdict(pass) }
624 else { setverdict(fail) }
625}
626
627testcase bitstrIsvalue() runs on bitstrOper_comptype{
628 var bitstring ostr0;
629 var bitstring ostr1 := '1111'B;
630 var template bitstring tostr;
631
632 if ( isvalue(ostr0) ) { setverdict(fail); } else { setverdict(pass); };
633 if ( isvalue(ostr1) ) { setverdict(pass); } else { setverdict(fail); };
634 if ( isvalue(tostr) ) { setverdict(fail); } else { setverdict(pass); };
635}
636
637testcase bitstrIsbound() runs on bitstrOper_comptype{
638 var bitstring ostr0;
639 var bitstring ostr1 := '1111'B;
640 var template bitstring tostr;
641
642 if ( isbound(ostr0) ) { setverdict(fail); } else { setverdict(pass); };
643 if ( isbound(ostr0[0]) ) { setverdict(fail); } else { setverdict(pass); };
644 if ( isbound(ostr1) ) { setverdict(pass); } else { setverdict(fail); };
645 if ( isbound(tostr) ) { setverdict(fail); } else { setverdict(pass); };
646}
647
648 control
649 {
650 const bitstring cl_1:='1000'B;
651 var bitstring vl_1;
652
653 execute(bitstrAssign());
654 execute(bitstrAssignElem10());
655 execute(bitstrAssignElem01());
656 execute(bitstrAssignElem00());
657 execute(bitstrAssignElem11());
658 execute(bitstrAssignElemAdd());
659 execute(bitstrLengthof());
660 execute(bitstrConst());
661 execute(bitstrComp_str_str());
662 execute(bitstrComp_el_str());
663 execute(bitstrComp_str_el());
664 execute(bitstrComp_el_el());
665 execute(bitstrConcat());
666 execute(bitstrNot_str());
667 execute(bitstrNot_el());
668 execute(bitstrAnd_str_str());
669 execute(bitstrAnd_el_str());
670 execute(bitstrAnd_str_el());
671 execute(bitstrAnd_el_el());
672 execute(bitstrOr_str_str());
673 execute(bitstrOr_el_str());
674 execute(bitstrOr_str_el());
675 execute(bitstrOr_el_el());
676 execute(bitstrXor_str_str());
677 execute(bitstrXor_el_str());
678 execute(bitstrXor_str_el());
679 execute(bitstrXor_el_el());
680 execute(bitstrShiftRight1());
681 execute(bitstrShiftRight2());
682 execute(bitstrShiftRightSum());
683 execute(bitstrShiftRightEmpty());
684 execute(bitstrShiftLeft1());
685 execute(bitstrShiftLeft2());
686 execute(bitstrShiftLeftSum());
687 execute(bitstrShiftLeftEmpty());
688 execute(bitstrRotateRight1());
689 execute(bitstrRotateRight2());
690 execute(bitstrRotateRightSum());
691 execute(bitstrRotateRightEmpty());
692 execute(bitstrRotateLeft1());
693 execute(bitstrRotateLeft2());
694 execute(bitstrRotateLeftSum());
695 execute(bitstrRotateLeftEmpty());
696 execute(bitstrSubtypes('0'B));
697 execute(bitstrIsvalue());
698 execute(bitstrIsbound());
699 }
700}
Titan Core - Deliverables
This page took 0.079058 seconds and 5 git commands to generate.