regression_test/predefFunction/rotter_OK.ttcn

   1 /******************************************************************************
   2  * Copyright (c) 2000-2014 Ericsson Telecom AB
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  ******************************************************************************/
   8 module rotter_OK {
   9
  10 type component PDTestComponent {};
  11
  12
  13 /*--- ROTATE ON BITSTRING --------------------------------------------------*/
  14
  15 const     bitstring rotconb := '1000110001'B // '0000000000'B
  16 modulepar bitstring rotparb1 := rotconb
  17 modulepar bitstring rotparb2 := rotconb @> 2 // '0110001100'B
  18 modulepar bitstring rotparb3 := rotconb <@ 2 // '0011000110'B
  19 modulepar bitstring rotparb4 := rotconb <@ 5 // '1000110001'B
  20 modulepar bitstring rotparb5 := rotconb @> 5 // '1000110001'B
  21 modulepar bitstring rotparb6 := rotconb <@ 0 // '1000110001'B
  22 modulepar bitstring rotparb7 := rotconb @> 0 // '1000110001'B
  23 modulepar bitstring rotparb8 := rotconb <@ 11 // '0001100011'B
  24 modulepar bitstring rotparb9 := rotconb @> 11 // '1100011000'B
  25 modulepar bitstring rotparb10 := ''B
  26 modulepar bitstring rotparb11 := ''B @> 2
  27 modulepar bitstring rotparb12 := ''B <@ 2
  28 modulepar bitstring rotparb13 := ''B @> 0
  29 modulepar bitstring rotparb14 := ''B <@ 0
  30 modulepar bitstring rotparb15 := rotconb @> -2 // '0011000110'B
  31 modulepar bitstring rotparb16 := rotconb <@ -2 // '0110001100'B
  32
  33 testcase rotate_bitstr() runs on PDTestComponent{
  34
  35         var integer j;
  36
  37         if (rotparb1 == rotparb1 <@ lengthof(rotparb1))
  38              {setverdict(pass);}
  39         else {setverdict(fail);}
  40         if (rotparb1 == rotparb1 @> lengthof(rotparb1))
  41              {setverdict(pass);}
  42         else {setverdict(fail);}
  43         if (rotparb1 == rotparb2 <@ 2)
  44              {setverdict(pass);}
  45         else {setverdict(fail);}
  46         if (rotparb1 == rotparb3 @> 2)
  47              {setverdict(pass);}
  48         else {setverdict(fail);}
  49         if (rotparb1 == rotparb4 @> 5)
  50              {setverdict(pass);}
  51         else {setverdict(fail);}
  52         if (rotparb1 == rotparb5 <@ 5)
  53              {setverdict(pass);}
  54         else {setverdict(fail);}
  55         if (rotparb1 == rotparb6)
  56              {setverdict(pass);}
  57         else {setverdict(fail);}
  58         if (rotparb1 == rotparb7)
  59              {setverdict(pass);}
  60         else {setverdict(fail);}
  61         if (rotparb8 == '0001100011'B)
  62              {setverdict(pass);}
  63         else {setverdict(fail);}
  64         if (rotparb9 == '1100011000'B)
  65              {setverdict(pass);}
  66         else {setverdict(fail);}
  67         if ((rotparb10 == rotparb11)
  68         and (rotparb10 == rotparb12))
  69              {setverdict(pass);}
  70         else {setverdict(fail);}
  71         if ((rotparb10 == rotparb13)
  72         and (rotparb10 == rotparb14))
  73              {setverdict(pass);}
  74         else {setverdict(fail);}
  75         if (rotparb15 == rotparb3)
  76              {setverdict(pass);}
  77         else {setverdict(fail);}
  78         if (rotparb16 == rotparb2)
  79              {setverdict(pass);}
  80         else {setverdict(fail);}
  81
  82         var bitstring b1 := '0000011111'B
  83         for (j:=0; j<15; j:=j+1) {
  84         if ((b1 <@ j) @> j == b1)
  85              {setverdict(pass);}
  86         else {setverdict(fail);}
  87         if ((b1 <@ -j) <@ j == b1)
  88              {setverdict(pass);}
  89         else {setverdict(fail);}
  90         if ((b1 @> -j) @> j == b1)
  91              {setverdict(pass);}
  92         else {setverdict(fail);}
  93         if ((b1 @> 0 == b1)
  94         and (b1 <@ 0 == b1))
  95              {setverdict(pass);}
  96         else {setverdict(fail);}
  97         }
  98
  99         var bitstring b2 := '10101010101010101010'B
 100         for (j:=1; j<30; j:=j+2) {
 101         if ((b2 <@ j) != b2)
 102              {setverdict(pass);}
 103         else {setverdict(fail);}
 104         if ((b2 <@ j-1) == b2)
 105              {setverdict(pass);}
 106         else {setverdict(fail);}
 107         if ((b2 @> j) != b2)
 108              {setverdict(pass);}
 109         else {setverdict(fail);}
 110         if ((b2 @> j-1) == b2)
 111              {setverdict(pass);}
 112         else {setverdict(fail);}
 113         }
 114
 115
 116 }
 117
 118 /*--- ROTATE ON HEXSTRING --------------------------------------------------*/
 119
 120 const     hexstring rotconh := '1000110001'H // '0000000000'H
 121 modulepar hexstring rotparh1 := rotconh
 122 modulepar hexstring rotparh2 := rotconh @> 2 // '0110001100'H
 123 modulepar hexstring rotparh3 := rotconh <@ 2 // '0011000110'H
 124 modulepar hexstring rotparh4 := rotconh <@ 5 // '1000110001'H
 125 modulepar hexstring rotparh5 := rotconh @> 5 // '1000110001'H
 126 modulepar hexstring rotparh6 := rotconh <@ 0 // '1000110001'H
 127 modulepar hexstring rotparh7 := rotconh @> 0 // '1000110001'H
 128 modulepar hexstring rotparh8 := rotconh <@ 11 // '0001100011'H
 129 modulepar hexstring rotparh9 := rotconh @> 11 // '1100011000'H
 130 modulepar hexstring rotparh10 := ''H
 131 modulepar hexstring rotparh11 := ''H @> 2
 132 modulepar hexstring rotparh12 := ''H <@ 2
 133 modulepar hexstring rotparh13 := ''H @> 0
 134 modulepar hexstring rotparh14 := ''H <@ 0
 135 modulepar hexstring rotparh15 := rotconh @> -2 // '0011000110'H
 136 modulepar hexstring rotparh16 := rotconh <@ -2 // '0110001100'H
 137
 138 testcase rotate_hexstr() runs on PDTestComponent{
 139
 140         var integer j;
 141
 142
 143         if (rotparh1 == rotparh1 <@ lengthof(rotparh1))
 144              {setverdict(pass);}
 145         else {setverdict(fail);}
 146         if (rotparh1 == rotparh1 @> lengthof(rotparh1))
 147              {setverdict(pass);}
 148         else {setverdict(fail);}
 149         if (rotparh1 == rotparh2 <@ 2)
 150              {setverdict(pass);}
 151         else {setverdict(fail);}
 152         if (rotparh1 == rotparh3 @> 2)
 153              {setverdict(pass);}
 154         else {setverdict(fail);}
 155         if (rotparh1 == rotparh4 @> 5)
 156              {setverdict(pass);}
 157         else {setverdict(fail);}
 158         if (rotparh1 == rotparh5 <@ 5)
 159              {setverdict(pass);}
 160         else {setverdict(fail);}
 161         if (rotparh1 == rotparh6)
 162              {setverdict(pass);}
 163         else {setverdict(fail);}
 164         if (rotparh1 == rotparh7)
 165              {setverdict(pass);}
 166         else {setverdict(fail);}
 167         if (rotparh8 == '0001100011'H)
 168              {setverdict(pass);}
 169         else {setverdict(fail);}
 170         if (rotparh9 == '1100011000'H)
 171              {setverdict(pass);}
 172         else {setverdict(fail);}
 173         if ((rotparh10 == rotparh11)
 174         and (rotparh10 == rotparh12))
 175              {setverdict(pass);}
 176         else {setverdict(fail);}
 177         if ((rotparh10 == rotparh13)
 178         and (rotparh10 == rotparh14))
 179              {setverdict(pass);}
 180         else {setverdict(fail);}
 181         if (rotparh15 == rotparh3)
 182              {setverdict(pass);}
 183         else {setverdict(fail);}
 184         if (rotparh16 == rotparh2)
 185              {setverdict(pass);}
 186         else {setverdict(fail);}
 187
 188         var hexstring h1 := '0000011111'H
 189         for (j:=0; j<15; j:=j+1) {
 190         if ((h1 <@ j) @> j == h1)
 191              {setverdict(pass);}
 192         else {setverdict(fail);}
 193         if ((h1 <@ -j) <@ j == h1)
 194              {setverdict(pass);}
 195         else {setverdict(fail);}
 196         if ((h1 @> -j) @> j == h1)
 197              {setverdict(pass);}
 198         else {setverdict(fail);}
 199         if ((h1 @> 0 == h1)
 200         and (h1 <@ 0 == h1))
 201              {setverdict(pass);}
 202         else {setverdict(fail);}
 203         }
 204
 205         var hexstring h2 := '10101010101010101010'H
 206         for (j:=1; j<30; j:=j+2) {
 207         if ((h2 <@ j) != h2)
 208              {setverdict(pass);}
 209         else {setverdict(fail);}
 210         if ((h2 <@ j-1) == h2)
 211              {setverdict(pass);}
 212         else {setverdict(fail);}
 213         if ((h2 @> j) != h2)
 214              {setverdict(pass);}
 215         else {setverdict(fail);}
 216         if ((h2 @> j-1) == h2)
 217              {setverdict(pass);}
 218         else {setverdict(fail);}
 219         }
 220
 221
 222 }
 223
 224 /*--- ROTATE ON OCTETSTRING --------------------------------------------------*/
 225
 226 const octetstring rotcono  := 'AA00AA00AA'O
 227 modulepar octetstring rotparo1 := rotcono
 228 modulepar octetstring rotparo2 := rotcono @> 1 // 'AAAA00AA00'O
 229 modulepar octetstring rotparo3 := rotcono <@ 1 // '00AA00AAAA'O
 230 modulepar octetstring rotparo4 := rotcono <@ 5 // 'AA00AA00AA'O
 231 modulepar octetstring rotparo5 := rotcono @> 5 // 'AA00AA00AA'O
 232 modulepar octetstring rotparo6 := rotcono <@ 0 // 'AA00AA00AA'O
 233 modulepar octetstring rotparo7 := rotcono @> 0 // 'AA00AA00AA'O
 234 modulepar octetstring rotparo8 := rotcono <@ 11 // '00AA00AAAA'O
 235 modulepar octetstring rotparo9 := rotcono @> 11 // 'AAAA00AA00'O
 236 modulepar octetstring rotparo10 := ''O
 237 modulepar octetstring rotparo11 := ''O @> 2
 238 modulepar octetstring rotparo12 := ''O <@ 2
 239 modulepar octetstring rotparo13 := ''O @> 0
 240 modulepar octetstring rotparo14 := ''O <@ 0
 241 modulepar octetstring rotparo15 := rotcono @> -1 // '00AA00AAAA'O
 242 modulepar octetstring rotparo16 := rotcono <@ -1 // 'AAAA00AA00'O
 243
 244 testcase rotate_octetstr() runs on PDTestComponent{
 245
 246         var integer j;
 247
 248         if (rotparo1 == rotparo1 <@ lengthof(rotparo1))
 249              {setverdict(pass);}
 250         else {setverdict(fail);}
 251         if (rotparo1 == rotparo1 @> lengthof(rotparo1))
 252              {setverdict(pass);}
 253         else {setverdict(fail);}
 254         if (rotparo1 == rotparo2 <@ 1)
 255              {setverdict(pass);}
 256         else {setverdict(fail);}
 257         if (rotparo1 == rotparo3 @> 1)
 258              {setverdict(pass);}
 259         else {setverdict(fail);}
 260         if (rotparo1 == rotparo4 @> 5)
 261              {setverdict(pass);}
 262         else {setverdict(fail);}
 263         if (rotparo1 == rotparo5 <@ 5)
 264              {setverdict(pass);}
 265         else {setverdict(fail);}
 266         if (rotparo1 == rotparo6)
 267              {setverdict(pass);}
 268         else {setverdict(fail);}
 269         if (rotparo1 == rotparo7)
 270              {setverdict(pass);}
 271         else {setverdict(fail);}
 272         if (rotparo8 == '00AA00AAAA'O)
 273              {setverdict(pass);}
 274         else {setverdict(fail);}
 275         if (rotparo9 == 'AAAA00AA00'O)
 276              {setverdict(pass);}
 277         else {setverdict(fail);}
 278         if ((rotparo10 == rotparo11)
 279         and (rotparo10 == rotparo12))
 280              {setverdict(pass);}
 281         else {setverdict(fail);}
 282         if ((rotparo10 == rotparo13)
 283         and (rotparo10 == rotparo14))
 284              {setverdict(pass);}
 285         else {setverdict(fail);}
 286         if (rotparo15 == rotparo3)
 287              {setverdict(pass);}
 288         else {setverdict(fail);}
 289         if (rotparo16 == rotparo2)
 290              {setverdict(pass);}
 291         else {setverdict(fail);}
 292
 293
 294         var octetstring o1 := '0000011111'O
 295         for (j:=0; j<15; j:=j+1) {
 296         if ((o1 <@ j) @> j == o1)
 297              {setverdict(pass);}
 298         else {setverdict(fail);}
 299         if ((o1 <@ -j) <@ j == o1)
 300              {setverdict(pass);}
 301         else {setverdict(fail);}
 302         if ((o1 @> -j) @> j == o1)
 303              {setverdict(pass);}
 304         else {setverdict(fail);}
 305         if ((o1 @> 0 == o1)
 306         and (o1 <@ 0 == o1))
 307              {setverdict(pass);}
 308         else {setverdict(fail);}
 309         }
 310
 311         var octetstring o2 := '1100110011001100110011001100110011001100'O
 312         for (j:=1; j<30; j:=j+2) {
 313         if ((o2 <@ j) != o2)
 314              {setverdict(pass);}
 315         else {setverdict(fail);}
 316         if ((o2 <@ j-1) == o2)
 317              {setverdict(pass);}
 318         else {setverdict(fail);}
 319         if ((o2 @> j) != o2)
 320              {setverdict(pass);}
 321         else {setverdict(fail);}
 322         if ((o2 @> j-1) == o2)
 323              {setverdict(pass);}
 324         else {setverdict(fail);}
 325         }
 326
 327 }
 328
 329 /*--- ROTATE ON CHARSTRING --------------------------------------------------*/
 330
 331 const     charstring rotconc := "1000110001" // "0000000000"
 332 modulepar charstring rotparc1 := rotconc
 333 modulepar charstring rotparc2 := rotconc @> 2 // "0110001100"
 334 modulepar charstring rotparc3 := rotconc <@ 2 // "0011000110"
 335 modulepar charstring rotparc4 := rotconc <@ 5 // "1000110001"
 336 modulepar charstring rotparc5 := rotconc @> 5 // "1000110001"
 337 modulepar charstring rotparc6 := rotconc <@ 0 // "1000110001"
 338 modulepar charstring rotparc7 := rotconc @> 0 // "1000110001"
 339 modulepar charstring rotparc8 := rotconc <@ 11 // "0001100011"
 340 modulepar charstring rotparc9 := rotconc @> 11 // "1100011000"
 341 modulepar charstring rotparc10 := ""
 342 modulepar charstring rotparc11 := "" @> 2
 343 modulepar charstring rotparc12 := "" <@ 2
 344 modulepar charstring rotparc13 := "" @> 0
 345 modulepar charstring rotparc14 := "" <@ 0
 346 modulepar charstring rotparc15 := rotconc @> -2 // "0011000110"
 347 modulepar charstring rotparc16 := rotconc <@ -2 // "0110001100"
 348
 349 testcase rotate_char() runs on PDTestComponent{
 350
 351         var integer j;
 352
 353         if (rotparc1 == rotparc1 <@ lengthof(rotparc1))
 354              {setverdict(pass);}
 355         else {setverdict(fail);}
 356         if (rotparc1 == rotparc1 @> lengthof(rotparc1))
 357              {setverdict(pass);}
 358         else {setverdict(fail);}
 359         if (rotparc1 == rotparc2 <@ 2)
 360              {setverdict(pass);}
 361         else {setverdict(fail);}
 362         if (rotparc1 == rotparc3 @> 2)
 363              {setverdict(pass);}
 364         else {setverdict(fail);}
 365         if (rotparc1 == rotparc4 @> 5)
 366              {setverdict(pass);}
 367         else {setverdict(fail);}
 368         if (rotparc1 == rotparc5 <@ 5)
 369              {setverdict(pass);}
 370         else {setverdict(fail);}
 371         if (rotparc1 == rotparc6)
 372              {setverdict(pass);}
 373         else {setverdict(fail);}
 374         if (rotparc1 == rotparc7)
 375              {setverdict(pass);}
 376         else {setverdict(fail);}
 377         if (rotparc8 == "0001100011")
 378              {setverdict(pass);}
 379         else {setverdict(fail);}
 380         if (rotparc9 == "1100011000")
 381              {setverdict(pass);}
 382         else {setverdict(fail);}
 383         if ((rotparc10 == rotparc11)
 384         and (rotparc10 == rotparc12))
 385              {setverdict(pass);}
 386         else {setverdict(fail);}
 387         if ((rotparc10 == rotparc13)
 388         and (rotparc10 == rotparc14))
 389              {setverdict(pass);}
 390         else {setverdict(fail);}
 391         if (rotparc15 == rotparc3)
 392              {setverdict(pass);}
 393         else {setverdict(fail);}
 394         if (rotparc16 == rotparc2)
 395              {setverdict(pass);}
 396         else {setverdict(fail);}
 397
 398         var charstring c1 := "0000011111"
 399         for (j:=0; j<15; j:=j+1) {
 400
 401         if ((c1 <@ j) @> j == c1)
 402              {setverdict(pass);}
 403         else {setverdict(fail);}
 404         if ((c1 <@ -j) <@ j == c1)
 405              {setverdict(pass);}
 406         else {setverdict(fail);}
 407         if ((c1 @> -j) @> j == c1)
 408              {setverdict(pass);}
 409         else {setverdict(fail);}
 410         if ((c1 @> 0 == c1)
 411         and (c1 <@ 0 == c1))
 412              {setverdict(pass);}
 413         else {setverdict(fail);}
 414         }
 415
 416         var charstring c2 := "10101010101010101010"
 417         for (j:=1; j<30; j:=j+2) {
 418         if ((c2 <@ j) != c2)
 419              {setverdict(pass);}
 420         else {setverdict(fail);}
 421         if ((c2 <@ j-1) == c2)
 422              {setverdict(pass);}
 423         else {setverdict(fail);}
 424         if ((c2 @> j) != c2)
 425              {setverdict(pass);}
 426         else {setverdict(fail);}
 427         if ((c2 @> j-1) == c2)
 428              {setverdict(pass);}
 429         else {setverdict(fail);}
 430         }
 431
 432
 433 }
 434
 435
 436 /*--- ROTATE ON UNIVERSAL CHARSTRING --------------------------------------------------*/
 437
 438 //modulepar universal charstring rotconuc := "0000000000"
 439 const     universal charstring rotconuc  := char(0,0,0,65) & "000" & char(0,0,0,65) & char(0,0,0,65) & "000" & char(0,0,0,65) //A000AA000A
 440 modulepar universal charstring rotparuc1 := rotconuc
 441 modulepar universal charstring rotparuc2 := rotconuc @> 2               // "0AA000AA00"
 442 modulepar universal charstring rotparuc3 := rotconuc <@ 2               // "00AA000AA0"
 443 modulepar universal charstring rotparuc4 := rotconuc <@ 5               // "A000AA000A"
 444 modulepar universal charstring rotparuc5 := rotconuc @> 5               // "A000AA000A"
 445 modulepar universal charstring rotparuc6 := rotconuc <@ 0               // "A000AA000A"
 446 modulepar universal charstring rotparuc7 := rotconuc @> 0               // "A000AA000A"
 447 modulepar universal charstring rotparuc8 := rotconuc <@ 11      // "000AA000AA"
 448 modulepar universal charstring rotparuc9 := rotconuc @> 11      // "AA000AA000"
 449 modulepar universal charstring rotparuc10 := ""
 450 modulepar universal charstring rotparuc11 := "" @> 2
 451 modulepar universal charstring rotparuc12 := "" <@ 2
 452 modulepar universal charstring rotparuc13 := "" @> 0
 453 modulepar universal charstring rotparuc14 := "" <@ 0
 454 modulepar universal charstring rotparuc15 := rotconuc @> -2     // "00AA000AA0"
 455 modulepar universal charstring rotparuc16 := rotconuc <@ -2     // "0AA000AA00"
 456
 457 testcase rotate_uchar() runs on PDTestComponent{
 458
 459         var integer j;
 460         if (rotparuc1 == rotparuc1 <@ lengthof(rotparc1))
 461              {setverdict(pass);}
 462         else {setverdict(fail);}
 463         if (rotparuc1 == rotparuc1 @> lengthof(rotparc1))
 464              {setverdict(pass);}
 465         else {setverdict(fail);}
 466         if (rotparuc1 == rotparuc2 <@ 2)
 467              {setverdict(pass);}
 468         else {setverdict(fail);}
 469         if (rotparuc1 == rotparuc3 @> 2)
 470              {setverdict(pass);}
 471         else {setverdict(fail);}
 472         if (rotparuc1 == rotparuc4 @> 5)
 473              {setverdict(pass);}
 474         else {setverdict(fail);}
 475         if (rotparuc1 == rotparuc5 <@ 5)
 476              {setverdict(pass);}
 477         else {setverdict(fail);}
 478         if (rotparuc1 == rotparuc6)
 479              {setverdict(pass);}
 480         else {setverdict(fail);}
 481         if (rotparuc1 == rotparuc7)
 482              {setverdict(pass);}
 483         else {setverdict(fail);}
 484         if (rotparuc8 == "000AA000AA")
 485              {setverdict(pass);}
 486         else {setverdict(fail);}
 487         if (rotparuc9 == "AA000AA000")
 488              {setverdict(pass);}
 489         else {setverdict(fail);}
 490         if ((rotparuc10 == rotparuc11)
 491         and (rotparuc10 == rotparuc12))
 492              {setverdict(pass);}
 493         else {setverdict(fail);}
 494         if ((rotparuc10 == rotparuc13)
 495         and (rotparuc10 == rotparuc14))
 496              {setverdict(pass);}
 497         else {setverdict(fail);}
 498         if (rotparuc15 == rotparuc3)
 499              {setverdict(pass);}
 500         else {setverdict(fail);}
 501         if (rotparuc16 == rotparuc2)
 502              {setverdict(pass);}
 503         else {setverdict(fail);}
 504
 505         var universal charstring c1 := "0000011111"
 506         for (j:=0; j<15; j:=j+1) {
 507
 508         if ((c1 <@ j) @> j == c1)
 509              {setverdict(pass);}
 510         else {setverdict(fail);}
 511         if ((c1 <@ -j) <@ j == c1)
 512              {setverdict(pass);}
 513         else {setverdict(fail);}
 514         if ((c1 @> -j) @> j == c1)
 515              {setverdict(pass);}
 516         else {setverdict(fail);}
 517         if ((c1 @> 0 == c1)
 518         and (c1 <@ 0 == c1))
 519              {setverdict(pass);}
 520         else {setverdict(fail);}
 521         }
 522
 523         var charstring c2 := "10101010101010101010"
 524         for (j:=1; j<30; j:=j+2) {
 525         if ((c2 <@ j) != c2)
 526              {setverdict(pass);}
 527         else {setverdict(fail);}
 528         if ((c2 <@ j-1) == c2)
 529              {setverdict(pass);}
 530         else {setverdict(fail);}
 531         if ((c2 @> j) != c2)
 532              {setverdict(pass);}
 533         else {setverdict(fail);}
 534         if ((c2 @> j-1) == c2)
 535              {setverdict(pass);}
 536         else {setverdict(fail);}
 537         }
 538 }
 539
 540 control {
 541         execute (rotate_bitstr());
 542         execute (rotate_hexstr());
 543         execute (rotate_octetstr());
 544         execute (rotate_char());
 545         execute (rotate_uchar());
 546 }
 547
 548 }