regression_test/bitstrOper/TbitstrOper.ttcn

   1 /******************************************************************************
   2  * Copyright (c) 2000-2015 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  ******************************************************************************/
   8 module TbitstrOper
   9 { type component bitstrOper_comptype { };
  10 const bitstring TbitstrOper_const1:='1000'B;
  11
  12 testcase 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
  29 testcase 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
  53 testcase 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
  75 testcase 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
  97 testcase 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
 119 testcase 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
 131 testcase 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
 152 testcase 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
 160 testcase 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
 175 testcase 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
 190 testcase 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
 205 testcase 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
 220 testcase 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
 242 testcase 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
 252 testcase 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
 263 testcase 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
 272 testcase 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
 290 testcase 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
 308 testcase 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
 326 testcase 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
 335 testcase 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
 353 testcase 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
 371 testcase 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
 389 testcase 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
 398 testcase 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
 416 testcase 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);}
 430   if (x6=='0'B) {setverdict(pass);}     //"1" xor "1"
 431      else {setverdict(fail);}
 432 }
 433
 434 testcase 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
 452 testcase 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
 460 testcase 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
 468 testcase 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
 476 testcase 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
 484 testcase 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
 492 testcase 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
 500 testcase 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
 508 testcase 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
 516 testcase 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
 524 testcase 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
 532 testcase 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
 540 testcase 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
 548 testcase 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
 556 testcase 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
 564 testcase 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
 572 testcase 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
 580 type bitstring mybstr1
 581 type mybstr1 mybstr2
 582 type mybstr1 mybstr3 ('0'B, '1'B)
 583 type mybstr1 mybstr4 ('0'B, '1'B) length(1)
 584 type mybstr1 mybstr5 length(1)
 585 type mybstr1 mybstr6 (int2bit(512, 11), int2bit(1024, 11))
 586 // Length 0.
 587 type bitstring mybstr7 length(0..0)
 588 type bitstring MyByte length(8..8)
 589 type bitstring MyNibbleToByte length(4..8)
 590 type bitstring BitStrings1 ('0'B, '1'B)
 591 type bitstring BitStrings2 ('00'B, '01'B, '10'B, '10'B)
 592 type bitstring BitStrings_1_2 (BitStrings1, BitStrings2)
 593 type bitstring mybstr8 (mybstr3, mybstr4)
 594 type bitstring mybstr9 length(0..infinity)  // Full set.
 595
 596 const mybstr4 c_mybstr1 := '0'B
 597 const mybstr8 c_mybstr2 := c_mybstr1
 598
 599 template mybstr4 t_mybstr1 := '0'B
 600 template mybstr8 t_mybstr2 := t_mybstr1
 601 template mybstr7 t_mybstr3 := ''B length(0)
 602
 603 function 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
 611 testcase 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
 627 testcase 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
 637 testcase 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 }