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